reverting changes in package.json

.github/CODEOWNERS

@@ -1 +0,0 @@
-* @Azure/aks-atlanta

.github/ISSUE_TEMPLATE/issue--bug-report---feature-request.md

@@ -1,10 +0,0 @@
----
-name: 'Issue: Bug Report / Feature Request'
-about: Create a report to help us improve
-title: ''
-labels: need-to-triage
-assignees: ''
-
----
-
-

.github/workflows/TriggerIntegrationTests.sh

@@ -0,0 +1,33 @@
+token=$1
+commit=$2
+repository=$3
+prNumber=$4
+frombranch=$5
+tobranch=$6
+patUser=$7
+
+getPayLoad() {
+    cat <<EOF
+{
+    "event_type": "SetupHelmActionPR", 
+    "client_payload": 
+    {
+        "action": "SetupHelm", 
+        "commit": "$commit", 
+        "repository": "$repository", 
+        "prNumber": "$prNumber", 
+        "tobranch": "$tobranch", 
+        "frombranch": "$frombranch"
+    }
+}
+EOF
+}
+
+response=$(curl -u $patUser:$token -X POST https://api.github.com/repos/Azure/azure-actions-integration-tests/dispatches --data "$(getPayLoad)")
+
+if [ "$response" == "" ]; then
+    echo "Integration tests triggered successfully"
+else
+    echo "Triggering integration tests failed with: '$response'"
+    exit 1
+fi

.github/workflows/defaultLabels.yml

@@ -1,35 +0,0 @@
-name: setting-default-labels
-
-# Controls when the action will run.
-on:
-  schedule:
-    - cron: "0 0/3 * * *"
-
-# A workflow run is made up of one or more jobs that can run sequentially or in parallel
-jobs:
-  build:
-    # The type of runner that the job will run on
-    runs-on: ubuntu-latest
-
-    # Steps represent a sequence of tasks that will be executed as part of the job
-    steps:
-      - uses: actions/stale@v3
-        name: Setting issue as idle
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-          stale-issue-message: "This issue is idle because it has been open for 14 days with no activity."
-          stale-issue-label: "idle"
-          days-before-stale: 14
-          days-before-close: -1
-          operations-per-run: 100
-          exempt-issue-labels: "backlog"
-
-      - uses: actions/stale@v3
-        name: Setting PR as idle
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-          stale-pr-message: "This PR is idle because it has been open for 14 days with no activity."
-          stale-pr-label: "idle"
-          days-before-stale: 14
-          days-before-close: -1
-          operations-per-run: 100

.github/workflows/integration-tests.yml

@@ -2,64 +2,18 @@ name: "Trigger Integration tests"
 on:
   pull_request:
     branches:
-      - main
-      - "releases/*"
-jobs:
-  trigger-integration-tests:
-    name: Trigger Integration tests
-    runs-on: ubuntu-latest
-    env:
-      HELM_3_8_0: "v3.8.0"
-      HELM_3_7_2: "v3.7.2"
-      HELM_NO_V: "3.5.0"
-      PR_BASE_REF: ${{ github.event.pull_request.base.ref }}
-    steps:
-      - name: Check out repository
-        uses: actions/checkout@v2
-      - name: npm install and build
-        id: action-npm-build
-        run: |
-          echo $PR_BASE_REF
-          if [[ $PR_BASE_REF != releases/* ]]; then
-            npm install
-            npm run build
-          fi
-      - name: Setup helm
-        uses: ./
-        with:
-          version: ${{ env.HELM_3_8_0 }}
-      - name: Validate helm 3.8.0
-        run: |
-          if [[ $(helm version) != *$HELM_3_8_0* ]]; then
-            echo "HELM VERSION INCORRECT: HELM VERSION DOES NOT CONTAIN v3.8.0"
-            echo "HELM VERSION OUTPUT: $(helm version)"
-            exit 1
-          else
-            echo "HELM VERSION $HELM_3_8_0 INSTALLED SUCCESSFULLY"
-          fi
-      - name: Setup helm 3.7.2
-        uses: ./
-        with:
-          version: ${{ env.HELM_3_7_2 }}
-      - name: Validate 3.7.2
-        run: |
-          if [[ $(helm version) != *$HELM_3_7_2* ]]; then
-            echo "HELM VERSION INCORRECT: HELM VERSION DOES NOT CONTAIN v3.7.2"
-            echo "HELM VERSION OUTPUT: $(helm version)"
-            exit 1
-          else
-            echo "HELM VERSION $HELM_3_7_2 INSTALLED SUCCESSFULLY"
-          fi
-      - name: Setup helm 3.5.0 with no v in version
-        uses: ./
-        with:
-          version: ${{ env.HELM_NO_V }}
-      - name: Validate 3.5.0 without v in version
-        run: |
-          if [[ $(helm version) != *$HELM_NO_V* ]]; then
-            echo "HELM VERSION INCORRECT: HELM VERSION DOES NOT CONTAIN v3.5.0"
-            echo "HELM VERSION OUTPUT: $(helm version)"
-            exit 1
-          else
-            echo "HELM VERSION $HELM_3_5_0 INSTALLED SUCCESSFULLY"
-          fi
+      - master
+      - 'releases/*'
+jobs: 
+    trigger-integration-tests:
+      name: Trigger Integration tests
+      runs-on: ubuntu-latest
+      steps:
+        - name: Check out repository
+          uses: actions/checkout@v2
+          with:
+              path: IntegrationTests
+            
+        - name: Trigger Test run
+          run: |
+            bash ./IntegrationTests/.github/workflows/TriggerIntegrationTests.sh ${{ secrets.L2_REPO_TOKEN }} ${{ github.event.pull_request.head.sha }} ${{ github.repository }} ${{ github.event.pull_request.number }} ${{ github.event.pull_request.head.ref }} ${{ github.event.pull_request.base.ref }} ${{ secrets.L2_REPO_USER }}

.github/workflows/release-pr.yml

@@ -1,14 +0,0 @@
-name: Create release PR
-
-on:
-  workflow_dispatch:
-    inputs:
-      release:
-        description: "Define release version (ex: v1, v2, v3)"
-        required: true
-
-jobs:
-  release-pr:
-    uses: OliverMKing/javascript-release-workflow/.github/workflows/release-pr.yml@main
-    with:
-      release: ${{ github.event.inputs.release }}

.github/workflows/tag-and-draft.yml

@@ -1,10 +0,0 @@
-name: Tag and create release draft
-
-on:
-  push:
-    branches:
-      - releases/*
-
-jobs:
-  tag-and-release:
-    uses: OliverMKing/javascript-release-workflow/.github/workflows/tag-and-release.yml@main

.github/workflows/unit-tests.yml

@@ -2,20 +2,20 @@ name: "Run unit tests."
 on: # rebuild any PRs and main branch changes
   pull_request:
     branches:
-      - main
-      - "releases/*"
+      - master
+      - 'releases/*'
   push:
     branches:
-      - main
-      - "releases/*"
+      - master
+      - 'releases/*'
 
 jobs:
   build: # make sure build/ci works properly
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v1
-
-      - name: Run L0 tests.
-        run: |
-          npm install
-          npm test
+    - uses: actions/checkout@v1
+    
+    - name: Run L0 tests.
+      run: |
+        npm install
+        npm test

.gitignore

@@ -62,6 +62,3 @@ typings/
 
 node_modules
 coverage
-
-# Transpiled JS
-lib/

README.md

@@ -1,6 +1,5 @@
 # Setup Helm
-Install a specific version of helm binary on the runner.
-## Example
+#### Install a specific version of helm binary on the runner.
 
 Acceptable values are latest or any semantic version string like v2.16.7 Use this action in workflow to define which version of helm will be used.
 

__tests__/run.test.ts

@@ -0,0 +1,195 @@
+import * as run from '../src/run'
+import * as os from 'os';
+import * as toolCache from '@actions/tool-cache';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as core from '@actions/core';
+
+describe('run.ts', () => {
+    test('getExecutableExtension() - return .exe when os is Windows', () => {
+        jest.spyOn(os, 'type').mockReturnValue('Windows_NT');
+
+        expect(run.getExecutableExtension()).toBe('.exe');
+        expect(os.type).toBeCalled();         
+    });
+
+    test('getExecutableExtension() - return empty string for non-windows OS', () => {
+        jest.spyOn(os, 'type').mockReturnValue('Darwin');
+
+        expect(run.getExecutableExtension()).toBe('');         
+        expect(os.type).toBeCalled();         
+    });
+
+    test('getHelmDownloadURL() - return the URL to download helm for Linux', () => {
+        jest.spyOn(os, 'type').mockReturnValue('Linux');
+        const kubectlLinuxUrl = 'https://get.helm.sh/helm-v3.2.1-linux-amd64.zip'
+
+        expect(run.getHelmDownloadURL('v3.2.1')).toBe(kubectlLinuxUrl);
+        expect(os.type).toBeCalled();         
+    });
+
+    test('getHelmDownloadURL() - return the URL to download helm for Darwin', () => {
+        jest.spyOn(os, 'type').mockReturnValue('Darwin');
+        const kubectlDarwinUrl = 'https://get.helm.sh/helm-v3.2.1-darwin-amd64.zip'
+
+        expect(run.getHelmDownloadURL('v3.2.1')).toBe(kubectlDarwinUrl);
+        expect(os.type).toBeCalled();         
+    });
+
+    test('getHelmDownloadURL() - return the URL to download helm for Windows', () => {
+        jest.spyOn(os, 'type').mockReturnValue('Windows_NT');
+
+        const kubectlWindowsUrl = 'https://get.helm.sh/helm-v3.2.1-windows-amd64.zip'
+        expect(run.getHelmDownloadURL('v3.2.1')).toBe(kubectlWindowsUrl);
+        expect(os.type).toBeCalled();         
+    });
+
+    test('getStableHelmVersion() - download stable version file, read version and return it', async () => {
+        jest.spyOn(toolCache, 'downloadTool').mockResolvedValue('pathToTool');
+        const response = JSON.stringify(
+            [
+                {
+                    'tag_name': 'v4.0.0'
+                }, {
+                    'tag_name': 'v3.0.0'
+                }, {
+                    'tag_name': 'v2.0.0'
+                }
+            ]
+        );
+        jest.spyOn(fs, 'readFileSync').mockReturnValue(response);
+
+        expect(await run.getStableHelmVersion()).toBe('v4.0.0');
+        expect(toolCache.downloadTool).toBeCalled();
+        expect(fs.readFileSync).toBeCalledWith('pathToTool', 'utf8');
+    });
+
+    test('getStableHelmVersion() - return default version if error occurs while getting latest version', async () => {
+        jest.spyOn(toolCache, 'downloadTool').mockRejectedValue('Unable to download');
+        jest.spyOn(core, 'warning').mockImplementation();
+
+        expect(await run.getStableHelmVersion()).toBe('v3.2.1');
+        expect(toolCache.downloadTool).toBeCalled();
+        expect(core.warning).toBeCalledWith("Cannot get the latest Helm info from https://api.github.com/repos/helm/helm/releases. Error Unable to download. Using default Helm version v3.2.1.");
+    });
+
+    test('walkSync() - return path to the all files matching fileToFind in dir', () => {
+        jest.spyOn(fs, 'readdirSync').mockImplementation((file, _) => {
+            if (file == 'mainFolder') return ['file1' as unknown as fs.Dirent, 'file2' as unknown as fs.Dirent, 'folder1' as unknown as fs.Dirent, 'folder2' as unknown as fs.Dirent];
+            if (file == path.join('mainFolder', 'folder1')) return ['file11' as unknown as fs.Dirent, 'file12' as unknown as fs.Dirent];
+            if (file == path.join('mainFolder', 'folder2')) return ['file21' as unknown as fs.Dirent, 'file22' as unknown as fs.Dirent];
+        });
+        jest.spyOn(core, 'debug').mockImplementation();
+        jest.spyOn(fs, 'statSync').mockImplementation((file) => {
+            const isDirectory = (file as string).toLowerCase().indexOf('file') == -1 ? true: false
+            return { isDirectory: () => isDirectory } as fs.Stats;
+        });
+
+        expect(run.walkSync('mainFolder', null, 'file21')).toEqual([path.join('mainFolder', 'folder2', 'file21')]);
+        expect(fs.readdirSync).toBeCalledTimes(3);
+        expect(fs.statSync).toBeCalledTimes(8);
+    });
+
+    test('walkSync() - return empty array if no file with name fileToFind exists', () => {
+        jest.spyOn(fs, 'readdirSync').mockImplementation((file, _) => {
+            if (file == 'mainFolder') return ['file1' as unknown as fs.Dirent, 'file2' as unknown as fs.Dirent, 'folder1' as unknown as fs.Dirent, 'folder2' as unknown as fs.Dirent];
+            if (file == path.join('mainFolder', 'folder1')) return ['file11' as unknown as fs.Dirent, 'file12' as unknown as fs.Dirent];
+            if (file == path.join('mainFolder', 'folder2')) return ['file21' as unknown as fs.Dirent, 'file22' as unknown as fs.Dirent];
+        });
+        jest.spyOn(core, 'debug').mockImplementation();
+        jest.spyOn(fs, 'statSync').mockImplementation((file) => {
+            const isDirectory = (file as string).toLowerCase().indexOf('file') == -1 ? true: false
+            return { isDirectory: () => isDirectory } as fs.Stats;
+        });
+
+        expect(run.walkSync('mainFolder', null, 'helm.exe')).toEqual([]);
+        expect(fs.readdirSync).toBeCalledTimes(3);
+        expect(fs.statSync).toBeCalledTimes(8);
+    });
+
+    test('findHelm() - change access permissions and find the helm in given directory', () => {
+        jest.spyOn(fs, 'chmodSync').mockImplementation(() => {});
+        jest.spyOn(fs, 'readdirSync').mockImplementation((file, _) => {
+            if (file == 'mainFolder') return ['helm.exe' as unknown as fs.Dirent];
+        });
+        jest.spyOn(fs, 'statSync').mockImplementation((file) => {
+            const isDirectory = (file as string).indexOf('folder') == -1 ? false: true
+            return { isDirectory: () => isDirectory } as fs.Stats;
+        });
+        jest.spyOn(os, 'type').mockReturnValue('Windows_NT');
+
+        expect(run.findHelm('mainFolder')).toBe(path.join('mainFolder', 'helm.exe'));
+    });
+
+    test('findHelm() - throw error if executable not found', () => {
+        jest.spyOn(fs, 'chmodSync').mockImplementation(() => {});
+        jest.spyOn(fs, 'readdirSync').mockImplementation((file, _) => {
+            if (file == 'mainFolder') return [];
+        });
+        jest.spyOn(fs, 'statSync').mockImplementation((file) => { return { isDirectory: () => true } as fs.Stats});
+        jest.spyOn(os, 'type').mockReturnValue('Windows_NT');
+        expect(() => run.findHelm('mainFolder')).toThrow('Helm executable not found in path mainFolder');
+    });
+
+    test('downloadHelm() - download helm and return path to it', async () => {
+        jest.spyOn(toolCache, 'find').mockReturnValue('');
+        jest.spyOn(toolCache, 'downloadTool').mockResolvedValue('pathToTool');
+        const response = JSON.stringify([{'tag_name': 'v4.0.0'}]);
+        jest.spyOn(fs, 'readFileSync').mockReturnValue(response);
+        jest.spyOn(os, 'type').mockReturnValue('Windows_NT');
+        jest.spyOn(fs, 'chmodSync').mockImplementation(() => {});
+        jest.spyOn(toolCache, 'extractZip').mockResolvedValue('pathToUnzippedHelm');
+        jest.spyOn(toolCache, 'cacheDir').mockResolvedValue('pathToCachedDir');
+        jest.spyOn(fs, 'readdirSync').mockImplementation((file, _) => ['helm.exe' as unknown as fs.Dirent]);
+        jest.spyOn(fs, 'statSync').mockImplementation((file) => {
+            const isDirectory = (file as string).indexOf('folder') == -1 ? false: true
+            return { isDirectory: () =>  isDirectory } as fs.Stats;
+        });
+
+        expect(await run.downloadHelm(null)).toBe(path.join('pathToCachedDir', 'helm.exe'));
+        expect(toolCache.find).toBeCalledWith('helm', 'v4.0.0');
+        expect(toolCache.downloadTool).toBeCalledWith('https://get.helm.sh/helm-v4.0.0-windows-amd64.zip');
+        expect(fs.chmodSync).toBeCalledWith('pathToTool', '777');
+        expect(toolCache.extractZip).toBeCalledWith('pathToTool');
+        expect(fs.chmodSync).toBeCalledWith(path.join('pathToCachedDir', 'helm.exe'), '777');
+    });
+
+    test('downloadHelm() - throw error if unable to download', async () => {
+        jest.spyOn(toolCache, 'find').mockReturnValue('');
+        jest.spyOn(toolCache, 'downloadTool').mockImplementation(async () => { throw 'Unable to download'});
+        jest.spyOn(os, 'type').mockReturnValue('Windows_NT');
+
+        await expect(run.downloadHelm('v3.2.1')).rejects.toThrow('Failed to download Helm from location https://get.helm.sh/helm-v3.2.1-windows-amd64.zip');
+        expect(toolCache.find).toBeCalledWith('helm', 'v3.2.1');
+        expect(toolCache.downloadTool).toBeCalledWith('https://get.helm.sh/helm-v3.2.1-windows-amd64.zip');
+    });
+
+    test('downloadHelm() - return path to helm tool with same version from toolCache', async () => {
+        jest.spyOn(toolCache, 'find').mockReturnValue('pathToCachedDir');
+        jest.spyOn(fs, 'chmodSync').mockImplementation(() => {});
+
+        expect(await run.downloadHelm('v3.2.1')).toBe(path.join('pathToCachedDir', 'helm.exe'));
+        expect(toolCache.find).toBeCalledWith('helm', 'v3.2.1');
+        expect(fs.chmodSync).toBeCalledWith(path.join('pathToCachedDir', 'helm.exe'), '777');
+    });
+
+    test('downloadHelm() - throw error is helm is not found in path', async () => {
+        jest.spyOn(toolCache, 'find').mockReturnValue('');
+        jest.spyOn(toolCache, 'downloadTool').mockResolvedValue('pathToTool');
+        jest.spyOn(os, 'type').mockReturnValue('Windows_NT');
+        jest.spyOn(fs, 'chmodSync').mockImplementation();
+        jest.spyOn(toolCache, 'extractZip').mockResolvedValue('pathToUnzippedHelm');
+        jest.spyOn(toolCache, 'cacheDir').mockResolvedValue('pathToCachedDir');
+        jest.spyOn(fs, 'readdirSync').mockImplementation((file, _) => []);
+        jest.spyOn(fs, 'statSync').mockImplementation((file) => {
+            const isDirectory = (file as string).indexOf('folder') == -1 ? false: true
+            return { isDirectory: () =>  isDirectory } as fs.Stats;
+        });
+
+        await expect(run.downloadHelm('v3.2.1')).rejects.toThrow('Helm executable not found in path pathToCachedDir');
+        expect(toolCache.find).toBeCalledWith('helm', 'v3.2.1');
+        expect(toolCache.downloadTool).toBeCalledWith('https://get.helm.sh/helm-v3.2.1-windows-amd64.zip');
+        expect(fs.chmodSync).toBeCalledWith('pathToTool', '777');
+        expect(toolCache.extractZip).toBeCalledWith('pathToTool');
+    });
+});  

action.yml

@@ -1,15 +1,19 @@
-name: "Helm tool installer"
-description: "Install a specific version of helm binary. Acceptable values are latest or any semantic version string like 1.15.0"
+name: 'Helm tool installer'
+description: 'Install a specific version of helm binary. Acceptable values are latest or any semantic version string like 1.15.0'
 inputs:
   version:
-    description: "Version of helm"
+    description: 'Version of helm'
+    required: true
+    default: 'latest'
+  token:
+    description: 'Github token'
+    default: ${{ github.token }}
     required: true
-    default: "latest"
 outputs:
   helm-path:
-    description: "Path to the cached helm binary"
+    description: 'Path to the cached helm binary'
 branding:
-  color: "blue"
+  color: 'blue'
 runs:
-  using: "node12"
-  main: "lib/index.js"
+  using: 'node12'
+  main: 'lib/run.js'

lib/run.js

@@ -0,0 +1,222 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.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.getStableHelmVersion = void 0;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const util = __importStar(require("util"));
+const fs = __importStar(require("fs"));
+const semver = __importStar(require("semver"));
+const toolCache = __importStar(require("@actions/tool-cache"));
+const core = __importStar(require("@actions/core"));
+const graphql_1 = require("@octokit/graphql");
+const helmToolName = 'helm';
+const stableHelmVersion = 'v3.2.1';
+const stableHelm3Version = 'v3.5.3';
+const stableHelm2Version = 'v2.17.0';
+const LATEST_HELM2_VERSION = '2.*';
+const LATEST_HELM3_VERSION = '3.*';
+const helmAllReleasesUrl = 'https://api.github.com/repos/helm/helm/releases';
+function getExecutableExtension() {
+    if (os.type().match(/^Win/)) {
+        return '.exe';
+    }
+    return '';
+}
+function getHelmDownloadURL(version) {
+    switch (os.type()) {
+        case 'Linux':
+            return util.format('https://get.helm.sh/helm-%s-linux-amd64.zip', version);
+        case 'Darwin':
+            return util.format('https://get.helm.sh/helm-%s-darwin-amd64.zip', version);
+        case 'Windows_NT':
+        default:
+            return util.format('https://get.helm.sh/helm-%s-windows-amd64.zip', version);
+    }
+}
+function getStableHelmVersion() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const downloadPath = yield toolCache.downloadTool(helmAllReleasesUrl);
+            const responseArray = JSON.parse(fs.readFileSync(downloadPath, 'utf8').toString().trim());
+            let latestHelmVersion = semver.clean(stableHelmVersion);
+            responseArray.forEach(response => {
+                if (response && response.tag_name) {
+                    let currentHelmVerison = semver.clean(response.tag_name.toString());
+                    if (currentHelmVerison) {
+                        if (currentHelmVerison.toString().indexOf('rc') == -1 && semver.gt(currentHelmVerison, latestHelmVersion)) {
+                            //If current helm version is not a pre release and is greater than latest helm version
+                            latestHelmVersion = currentHelmVerison;
+                        }
+                    }
+                }
+            });
+            latestHelmVersion = "v" + latestHelmVersion;
+            return latestHelmVersion;
+        }
+        catch (error) {
+            core.warning(util.format("Cannot get the latest Helm info from %s. Error %s. Using default Helm version %s.", helmAllReleasesUrl, error, stableHelmVersion));
+        }
+        return stableHelmVersion;
+    });
+}
+exports.getStableHelmVersion = getStableHelmVersion;
+var walkSync = function (dir, filelist, fileToFind) {
+    var files = fs.readdirSync(dir);
+    filelist = filelist || [];
+    files.forEach(function (file) {
+        if (fs.statSync(path.join(dir, file)).isDirectory()) {
+            filelist = walkSync(path.join(dir, file), filelist, fileToFind);
+        }
+        else {
+            core.debug(file);
+            if (file == fileToFind) {
+                filelist.push(path.join(dir, file));
+            }
+        }
+    });
+    return filelist;
+};
+function downloadHelm(version) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!version) {
+            version = yield getLatestHelmVersionFor("v3");
+        }
+        let cachedToolpath = toolCache.find(helmToolName, version);
+        if (!cachedToolpath) {
+            let helmDownloadPath;
+            try {
+                helmDownloadPath = yield toolCache.downloadTool(getHelmDownloadURL(version));
+            }
+            catch (exception) {
+                throw new Error(util.format("Failed to download Helm from location ", getHelmDownloadURL(version)));
+            }
+            fs.chmodSync(helmDownloadPath, '777');
+            const unzipedHelmPath = yield toolCache.extractZip(helmDownloadPath);
+            cachedToolpath = yield toolCache.cacheDir(unzipedHelmPath, helmToolName, version);
+        }
+        const helmpath = findHelm(cachedToolpath);
+        if (!helmpath) {
+            throw new Error(util.format("Helm executable not found in path ", cachedToolpath));
+        }
+        fs.chmodSync(helmpath, '777');
+        return helmpath;
+    });
+}
+function getLatestHelmVersionFor(type) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const token = core.getInput('token', { 'required': true });
+        try {
+            const { repository } = yield graphql_1.graphql(`{
+                repository(name: "helm", owner: "helm") {
+                    releases(last: 100)  {
+                        nodes {
+                            tagName
+                        }
+                    }
+                }
+            }`, {
+                headers: {
+                    authorization: `token ${token}`
+                }
+            });
+            const releases = repository.releases.nodes.reverse();
+            let latestValidRelease = releases.find(release => isValidVersion(release.tagName, type));
+            if (latestValidRelease)
+                return latestValidRelease.tagName;
+        }
+        catch (err) {
+            core.warning(util.format("Error while fetching the latest Helm %s release. Error: %s. Using default Helm version %s.", type, err.toString(), getStableHelmVersionFor(type)));
+            return getStableHelmVersionFor(type);
+        }
+        core.warning(util.format("Could not find stable release for Helm %s. Using default Helm version %s.", type, getStableHelmVersionFor(type)));
+        return getStableHelmVersionFor(type);
+    });
+}
+function getStableHelmVersionFor(type) {
+    return type === "v2" ? stableHelm2Version : stableHelm3Version;
+}
+// isValidVersion checks if verison matches the specified type and is a stable release
+function isValidVersion(version, type) {
+    if (!version.toLocaleLowerCase().startsWith(type))
+        return false;
+    return version.indexOf('rc') == -1;
+}
+function findHelm(rootFolder) {
+    fs.chmodSync(rootFolder, '777');
+    var filelist = [];
+    walkSync(rootFolder, filelist, helmToolName + getExecutableExtension());
+    if (!filelist) {
+        throw new Error(util.format("Helm executable not found in path ", rootFolder));
+    }
+    else {
+        return filelist[0];
+    }
+}
+function run() {
+    return __awaiter(this, void 0, void 0, function* () {
+        let version = core.getInput('version', { 'required': true });
+        if (process.env['HELM_INSTALLER_LEGACY_VERSIONING'] == 'true') {
+            if (version.toLocaleLowerCase() === 'latest') {
+                version = yield getStableHelmVersion();
+            }
+            else if (!version.toLocaleLowerCase().startsWith('v')) {
+                version = 'v' + version;
+            }
+        }
+        else {
+            if (version.toLocaleLowerCase() === 'latest' || version === LATEST_HELM3_VERSION) {
+                version = yield getLatestHelmVersionFor("v3");
+            }
+            else if (version === LATEST_HELM2_VERSION) {
+                version = yield getLatestHelmVersionFor("v2");
+            }
+            else if (!version.toLocaleLowerCase().startsWith('v')) {
+                version = 'v' + version;
+            }
+        }
+        core.debug(util.format("Downloading %s", version));
+        let cachedPath = yield downloadHelm(version);
+        try {
+            if (!process.env['PATH'].startsWith(path.dirname(cachedPath))) {
+                core.addPath(path.dirname(cachedPath));
+            }
+        }
+        catch (_a) {
+            //do nothing, set as output variable
+        }
+        console.log(`Helm tool version: '${version}' has been cached at ${cachedPath}`);
+        core.setOutput('helm-path', cachedPath);
+    });
+}
+run().catch(core.setFailed);

package.json

@@ -13,18 +13,17 @@
         "@octokit/graphql": "^4.6.1",
         "semver": "^6.1.0"
     },
-    "main": "lib/index.js",
+    "main": "lib/run.js",
     "scripts": {
-        "build": "ncc build src/run.ts -o lib",
+        "build": "tsc --outDir ./lib --rootDir ./src",
         "test": "jest",
         "test-coverage": "jest --coverage"
     },
     "devDependencies": {
-        "@types/jest": "^25.2.2",
         "@types/node": "^12.0.10",
-        "@vercel/ncc": "^0.33.1",
+        "typescript": "^3.5.2",
         "jest": "^26.0.1",
-        "ts-jest": "^25.5.1",
-        "typescript": "^3.5.2"
+        "@types/jest": "^25.2.2",
+        "ts-jest": "^25.5.1"
     }
-}
+}

src/run.test.ts

@@ -1,268 +0,0 @@
-import * as run from "./run";
-import * as os from "os";
-import * as toolCache from "@actions/tool-cache";
-import * as fs from "fs";
-import * as path from "path";
-import * as core from "@actions/core";
-
-describe("run.ts", () => {
-  test("getExecutableExtension() - return .exe when os is Windows", () => {
-    jest.spyOn(os, "type").mockReturnValue("Windows_NT");
-
-    expect(run.getExecutableExtension()).toBe(".exe");
-    expect(os.type).toBeCalled();
-  });
-
-  test("getExecutableExtension() - return empty string for non-windows OS", () => {
-    jest.spyOn(os, "type").mockReturnValue("Darwin");
-
-    expect(run.getExecutableExtension()).toBe("");
-    expect(os.type).toBeCalled();
-  });
-
-  test("getHelmDownloadURL() - return the URL to download helm for Linux", () => {
-    jest.spyOn(os, "type").mockReturnValue("Linux");
-    jest.spyOn(os, "arch").mockReturnValueOnce("unknown");
-    const kubectlLinuxUrl = "https://get.helm.sh/helm-v3.8.0-linux-amd64.zip";
-
-    expect(run.getHelmDownloadURL("v3.8.0")).toBe(kubectlLinuxUrl);
-    expect(os.type).toBeCalled();
-    expect(os.arch).toBeCalled();
-
-    // arm64
-    jest.spyOn(os, "type").mockReturnValue("Linux");
-    jest.spyOn(os, "arch").mockReturnValueOnce("arm64");
-    const kubectlLinuxArm64Url =
-      "https://get.helm.sh/helm-v3.8.0-linux-arm64.zip";
-
-    expect(run.getHelmDownloadURL("v3.8.0")).toBe(kubectlLinuxArm64Url);
-    expect(os.type).toBeCalled();
-    expect(os.arch).toBeCalled();
-  });
-
-  test("getHelmDownloadURL() - return the URL to download helm for Darwin", () => {
-    jest.spyOn(os, "type").mockReturnValue("Darwin");
-    jest.spyOn(os, "arch").mockReturnValueOnce("unknown");
-    const kubectlDarwinUrl = "https://get.helm.sh/helm-v3.8.0-darwin-amd64.zip";
-
-    expect(run.getHelmDownloadURL("v3.8.0")).toBe(kubectlDarwinUrl);
-    expect(os.type).toBeCalled();
-    expect(os.arch).toBeCalled();
-
-    // arm64
-    jest.spyOn(os, "type").mockReturnValue("Darwin");
-    jest.spyOn(os, "arch").mockReturnValueOnce("arm64");
-    const kubectlDarwinArm64Url =
-      "https://get.helm.sh/helm-v3.8.0-darwin-arm64.zip";
-
-    expect(run.getHelmDownloadURL("v3.8.0")).toBe(kubectlDarwinArm64Url);
-    expect(os.type).toBeCalled();
-    expect(os.arch).toBeCalled();
-  });
-
-  test("getValidVersion() - return version with v prepended", () => {
-      expect(run.getValidVersion("3.8.0")).toBe("v3.8.0");
-  });
-  
-  test("getHelmDownloadURL() - return the URL to download helm for Windows", () => {
-    jest.spyOn(os, "type").mockReturnValue("Windows_NT");
-
-    const kubectlWindowsUrl =
-      "https://get.helm.sh/helm-v3.8.0-windows-amd64.zip";
-    expect(run.getHelmDownloadURL("v3.8.0")).toBe(kubectlWindowsUrl);
-    expect(os.type).toBeCalled();
-  });
-
-  test("getLatestHelmVersion() - return the latest version of HELM", async () => {
-    try {
-      expect(await run.getLatestHelmVersion()).toBe("v3.8.0");
-    } catch (e) {
-      return e;
-    }
-  });
-
-  test("walkSync() - return path to the all files matching fileToFind in dir", () => {
-    jest.spyOn(fs, "readdirSync").mockImplementation((file, _) => {
-      if (file == "mainFolder")
-        return [
-          "file1" as unknown as fs.Dirent,
-          "file2" as unknown as fs.Dirent,
-          "folder1" as unknown as fs.Dirent,
-          "folder2" as unknown as fs.Dirent,
-        ];
-      if (file == path.join("mainFolder", "folder1"))
-        return [
-          "file11" as unknown as fs.Dirent,
-          "file12" as unknown as fs.Dirent,
-        ];
-      if (file == path.join("mainFolder", "folder2"))
-        return [
-          "file21" as unknown as fs.Dirent,
-          "file22" as unknown as fs.Dirent,
-        ];
-    });
-    jest.spyOn(core, "debug").mockImplementation();
-    jest.spyOn(fs, "statSync").mockImplementation((file) => {
-      const isDirectory =
-        (file as string).toLowerCase().indexOf("file") == -1 ? true : false;
-      return { isDirectory: () => isDirectory } as fs.Stats;
-    });
-
-    expect(run.walkSync("mainFolder", null, "file21")).toEqual([
-      path.join("mainFolder", "folder2", "file21"),
-    ]);
-    expect(fs.readdirSync).toBeCalledTimes(3);
-    expect(fs.statSync).toBeCalledTimes(8);
-  });
-
-  test("walkSync() - return empty array if no file with name fileToFind exists", () => {
-    jest.spyOn(fs, "readdirSync").mockImplementation((file, _) => {
-      if (file == "mainFolder")
-        return [
-          "file1" as unknown as fs.Dirent,
-          "file2" as unknown as fs.Dirent,
-          "folder1" as unknown as fs.Dirent,
-          "folder2" as unknown as fs.Dirent,
-        ];
-      if (file == path.join("mainFolder", "folder1"))
-        return [
-          "file11" as unknown as fs.Dirent,
-          "file12" as unknown as fs.Dirent,
-        ];
-      if (file == path.join("mainFolder", "folder2"))
-        return [
-          "file21" as unknown as fs.Dirent,
-          "file22" as unknown as fs.Dirent,
-        ];
-    });
-    jest.spyOn(core, "debug").mockImplementation();
-    jest.spyOn(fs, "statSync").mockImplementation((file) => {
-      const isDirectory =
-        (file as string).toLowerCase().indexOf("file") == -1 ? true : false;
-      return { isDirectory: () => isDirectory } as fs.Stats;
-    });
-
-    expect(run.walkSync("mainFolder", null, "helm.exe")).toEqual([]);
-    expect(fs.readdirSync).toBeCalledTimes(3);
-    expect(fs.statSync).toBeCalledTimes(8);
-  });
-
-  test("findHelm() - change access permissions and find the helm in given directory", () => {
-    jest.spyOn(fs, "chmodSync").mockImplementation(() => {});
-    jest.spyOn(fs, "readdirSync").mockImplementation((file, _) => {
-      if (file == "mainFolder") return ["helm.exe" as unknown as fs.Dirent];
-    });
-    jest.spyOn(fs, "statSync").mockImplementation((file) => {
-      const isDirectory =
-        (file as string).indexOf("folder") == -1 ? false : true;
-      return { isDirectory: () => isDirectory } as fs.Stats;
-    });
-    jest.spyOn(os, "type").mockReturnValue("Windows_NT");
-
-    expect(run.findHelm("mainFolder")).toBe(
-      path.join("mainFolder", "helm.exe")
-    );
-  });
-
-  test("findHelm() - throw error if executable not found", () => {
-    jest.spyOn(fs, "chmodSync").mockImplementation(() => {});
-    jest.spyOn(fs, "readdirSync").mockImplementation((file, _) => {
-      if (file == "mainFolder") return [];
-    });
-    jest.spyOn(fs, "statSync").mockImplementation((file) => {
-      return { isDirectory: () => true } as fs.Stats;
-    });
-    jest.spyOn(os, "type").mockReturnValue("Windows_NT");
-    expect(() => run.findHelm("mainFolder")).toThrow(
-      "Helm executable not found in path mainFolder"
-    );
-  });
-
-  test("downloadHelm() - download helm and return path to it", async () => {
-    jest.spyOn(toolCache, "find").mockReturnValue("");
-    jest.spyOn(toolCache, "downloadTool").mockResolvedValue("pathToTool");
-    const response = JSON.stringify([{ tag_name: "v4.0.0" }]);
-    jest.spyOn(fs, "readFileSync").mockReturnValue(response);
-    jest.spyOn(os, "type").mockReturnValue("Windows_NT");
-    jest.spyOn(fs, "chmodSync").mockImplementation(() => {});
-    jest.spyOn(toolCache, "extractZip").mockResolvedValue("pathToUnzippedHelm");
-    jest.spyOn(toolCache, "cacheDir").mockResolvedValue("pathToCachedDir");
-    jest
-      .spyOn(fs, "readdirSync")
-      .mockImplementation((file, _) => ["helm.exe" as unknown as fs.Dirent]);
-    jest.spyOn(fs, "statSync").mockImplementation((file) => {
-      const isDirectory =
-        (file as string).indexOf("folder") == -1 ? false : true;
-      return { isDirectory: () => isDirectory } as fs.Stats;
-    });
-
-    expect(await run.downloadHelm("v4.0.0")).toBe(
-      path.join("pathToCachedDir", "helm.exe")
-    );
-    expect(toolCache.find).toBeCalledWith("helm", "v4.0.0");
-    expect(toolCache.downloadTool).toBeCalledWith(
-      "https://get.helm.sh/helm-v4.0.0-windows-amd64.zip"
-    );
-    expect(fs.chmodSync).toBeCalledWith("pathToTool", "777");
-    expect(toolCache.extractZip).toBeCalledWith("pathToTool");
-    expect(fs.chmodSync).toBeCalledWith(
-      path.join("pathToCachedDir", "helm.exe"),
-      "777"
-    );
-  });
-
-  test("downloadHelm() - throw error if unable to download", async () => {
-    jest.spyOn(toolCache, "find").mockReturnValue("");
-    jest.spyOn(toolCache, "downloadTool").mockImplementation(async () => {
-      throw "Unable to download";
-    });
-    jest.spyOn(os, "type").mockReturnValue("Windows_NT");
-
-    await expect(run.downloadHelm("v3.2.1")).rejects.toThrow(
-      "Failed to download Helm from location https://get.helm.sh/helm-v3.2.1-windows-amd64.zip"
-    );
-    expect(toolCache.find).toBeCalledWith("helm", "v3.2.1");
-    expect(toolCache.downloadTool).toBeCalledWith(
-      "https://get.helm.sh/helm-v3.2.1-windows-amd64.zip"
-    );
-  });
-
-  test("downloadHelm() - return path to helm tool with same version from toolCache", async () => {
-    jest.spyOn(toolCache, "find").mockReturnValue("pathToCachedDir");
-    jest.spyOn(fs, "chmodSync").mockImplementation(() => {});
-
-    expect(await run.downloadHelm("v3.2.1")).toBe(
-      path.join("pathToCachedDir", "helm.exe")
-    );
-    expect(toolCache.find).toBeCalledWith("helm", "v3.2.1");
-    expect(fs.chmodSync).toBeCalledWith(
-      path.join("pathToCachedDir", "helm.exe"),
-      "777"
-    );
-  });
-
-  test("downloadHelm() - throw error is helm is not found in path", async () => {
-    jest.spyOn(toolCache, "find").mockReturnValue("");
-    jest.spyOn(toolCache, "downloadTool").mockResolvedValue("pathToTool");
-    jest.spyOn(os, "type").mockReturnValue("Windows_NT");
-    jest.spyOn(fs, "chmodSync").mockImplementation();
-    jest.spyOn(toolCache, "extractZip").mockResolvedValue("pathToUnzippedHelm");
-    jest.spyOn(toolCache, "cacheDir").mockResolvedValue("pathToCachedDir");
-    jest.spyOn(fs, "readdirSync").mockImplementation((file, _) => []);
-    jest.spyOn(fs, "statSync").mockImplementation((file) => {
-      const isDirectory =
-        (file as string).indexOf("folder") == -1 ? false : true;
-      return { isDirectory: () => isDirectory } as fs.Stats;
-    });
-
-    await expect(run.downloadHelm("v3.2.1")).rejects.toThrow(
-      "Helm executable not found in path pathToCachedDir"
-    );
-    expect(toolCache.find).toBeCalledWith("helm", "v3.2.1");
-    expect(toolCache.downloadTool).toBeCalledWith(
-      "https://get.helm.sh/helm-v3.2.1-windows-amd64.zip"
-    );
-    expect(fs.chmodSync).toBeCalledWith("pathToTool", "777");
-    expect(toolCache.extractZip).toBeCalledWith("pathToTool");
-  });
-});

src/run.ts

@@ -2,193 +2,201 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 
-import * as os from "os";
-import * as path from "path";
-import * as util from "util";
-import * as fs from "fs";
+import * as os from 'os';
+import * as path from 'path';
+import * as util from 'util';
+import * as fs from 'fs';
+import * as semver from 'semver';
 
-import * as toolCache from "@actions/tool-cache";
-import * as core from "@actions/core";
+import * as toolCache from '@actions/tool-cache';
+import * as core from '@actions/core';
+import { graphql } from '@octokit/graphql';
 
-const helmToolName = "helm";
-const stableHelmVersion = "v3.8.0";
-const helmAllReleasesUrl = "https://api.github.com/repos/helm/helm/releases";
-
-export async function run() {
-  let version = core.getInput("version", { required: true });
-
-  if(version !== "latest" && version[0] !== "v"){
-      version = getValidVersion(version);
-  }
-  if (version.toLocaleLowerCase() === "latest") {
-    version = await getLatestHelmVersion();
-  }
-
-  core.debug(util.format("Downloading %s", version));
-  let cachedPath = await downloadHelm(version);
-
-  try {
-    if (!process.env["PATH"].startsWith(path.dirname(cachedPath))) {
-      core.addPath(path.dirname(cachedPath));
-    }
-  } catch {
-    //do nothing, set as output variable
-  }
-
-  console.log(
-    `Helm tool version: '${version}' has been cached at ${cachedPath}`
-  );
-  core.setOutput("helm-path", cachedPath);
-}
-
-//Returns version with proper v before it
-export function getValidVersion(version: string): string {
-    return "v" + version;
-} 
-
-// Downloads the helm releases JSON and parses all the recent versions of helm from it.
-// Defaults to sending stable helm version if none are valid or if it fails
-
-export async function getLatestHelmVersion(): Promise<string> {
-  const helmJSONPath: string = await toolCache.downloadTool(helmAllReleasesUrl);
-
-  try {
-    const helmJSON = JSON.parse(fs.readFileSync(helmJSONPath, "utf-8"));
-    for (let i in helmJSON) {
-      if (isValidVersion(helmJSON[i].tag_name)) {
-        return helmJSON[i].tag_name;
-      }
-    }
-  } catch (err) {
-    core.warning(
-      util.format(
-        "Error while fetching the latest Helm release. Error: %s. Using default Helm version %s",
-        err.toString(),
-        stableHelmVersion
-      )
-    );
-    return stableHelmVersion;
-  }
-
-  return stableHelmVersion;
-}
-
-// isValidVersion checks if verison is a stable release
-function isValidVersion(version: string): boolean {
-  return version.indexOf("rc") == -1;
-}
+const helmToolName = 'helm';
+const stableHelmVersion = 'v3.2.1';
+const stableHelm3Version = 'v3.5.3';
+const stableHelm2Version = 'v2.17.0';
+const LATEST_HELM2_VERSION = '2.*';
+const LATEST_HELM3_VERSION = '3.*';
+const helmAllReleasesUrl = 'https://api.github.com/repos/helm/helm/releases';
 
 export function getExecutableExtension(): string {
-  if (os.type().match(/^Win/)) {
-    return ".exe";
-  }
-  return "";
+    if (os.type().match(/^Win/)) {
+        return '.exe';
+    }
+    return '';
 }
 
-const LINUX = "Linux";
-const MAC_OS = "Darwin";
-const WINDOWS = "Windows_NT";
-const ARM64 = "arm64";
 export function getHelmDownloadURL(version: string): string {
-  const arch = os.arch();
-  const operatingSystem = os.type();
+    switch (os.type()) {
+        case 'Linux':
+            return util.format('https://get.helm.sh/helm-%s-linux-amd64.zip', version);
 
-  switch (true) {
-    case operatingSystem == LINUX && arch == ARM64:
-      return util.format(
-        "https://get.helm.sh/helm-%s-linux-arm64.zip",
-        version
-      );
-    case operatingSystem == LINUX:
-      return util.format(
-        "https://get.helm.sh/helm-%s-linux-amd64.zip",
-        version
-      );
+        case 'Darwin':
+            return util.format('https://get.helm.sh/helm-%s-darwin-amd64.zip', version);
 
-    case operatingSystem == MAC_OS && arch == ARM64:
-      return util.format(
-        "https://get.helm.sh/helm-%s-darwin-arm64.zip",
-        version
-      );
-    case operatingSystem == MAC_OS:
-      return util.format(
-        "https://get.helm.sh/helm-%s-darwin-amd64.zip",
-        version
-      );
-
-    case operatingSystem == WINDOWS:
-    default:
-      return util.format(
-        "https://get.helm.sh/helm-%s-windows-amd64.zip",
-        version
-      );
-  }
+        case 'Windows_NT':
+        default:
+            return util.format('https://get.helm.sh/helm-%s-windows-amd64.zip', version);
+    }
 }
 
-export async function downloadHelm(version: string): Promise<string> {
-  let cachedToolpath = toolCache.find(helmToolName, version);
-  if (!cachedToolpath) {
-    let helmDownloadPath;
+export async function getStableHelmVersion(): Promise<string> {
     try {
-      helmDownloadPath = await toolCache.downloadTool(
-        getHelmDownloadURL(version)
-      );
-    } catch (exception) {
-      throw new Error(
-        util.format(
-          "Failed to download Helm from location",
-          getHelmDownloadURL(version)
-        )
-      );
+        const downloadPath = await toolCache.downloadTool(helmAllReleasesUrl);
+        const responseArray = JSON.parse(fs.readFileSync(downloadPath, 'utf8').toString().trim());
+        let latestHelmVersion = semver.clean(stableHelmVersion);
+        responseArray.forEach(response => {
+            if (response && response.tag_name) {
+                let currentHelmVerison = semver.clean(response.tag_name.toString());
+                if (currentHelmVerison) {
+                    if (currentHelmVerison.toString().indexOf('rc') == -1 && semver.gt(currentHelmVerison, latestHelmVersion)) {
+                        //If current helm version is not a pre release and is greater than latest helm version
+                        latestHelmVersion = currentHelmVerison;
+                    }
+                }
+            }
+        });
+        latestHelmVersion = "v" + latestHelmVersion;
+        return latestHelmVersion;
+    } catch (error) {
+        core.warning(util.format("Cannot get the latest Helm info from %s. Error %s. Using default Helm version %s.", helmAllReleasesUrl, error, stableHelmVersion));
     }
 
-    fs.chmodSync(helmDownloadPath, "777");
-    const unzipedHelmPath = await toolCache.extractZip(helmDownloadPath);
-    cachedToolpath = await toolCache.cacheDir(
-      unzipedHelmPath,
-      helmToolName,
-      version
-    );
-  }
-
-  const helmpath = findHelm(cachedToolpath);
-  if (!helmpath) {
-    throw new Error(
-      util.format("Helm executable not found in path", cachedToolpath)
-    );
-  }
-
-  fs.chmodSync(helmpath, "777");
-  return helmpath;
-}
-
-export function findHelm(rootFolder: string): string {
-  fs.chmodSync(rootFolder, "777");
-  var filelist: string[] = [];
-  walkSync(rootFolder, filelist, helmToolName + getExecutableExtension());
-  if (!filelist || filelist.length == 0) {
-    throw new Error(
-      util.format("Helm executable not found in path", rootFolder)
-    );
-  } else {
-    return filelist[0];
-  }
+    return stableHelmVersion;
 }
 
 export var walkSync = function (dir, filelist, fileToFind) {
-  var files = fs.readdirSync(dir);
-  filelist = filelist || [];
-  files.forEach(function (file) {
-    if (fs.statSync(path.join(dir, file)).isDirectory()) {
-      filelist = walkSync(path.join(dir, file), filelist, fileToFind);
-    } else {
-      core.debug(file);
-      if (file == fileToFind) {
-        filelist.push(path.join(dir, file));
-      }
-    }
-  });
-  return filelist;
+    var files = fs.readdirSync(dir);
+    filelist = filelist || [];
+    files.forEach(function (file) {
+        if (fs.statSync(path.join(dir, file)).isDirectory()) {
+            filelist = walkSync(path.join(dir, file), filelist, fileToFind);
+        }
+        else {
+            core.debug(file);
+            if (file == fileToFind) {
+                filelist.push(path.join(dir, file));
+            }
+        }
+    });
+    return filelist;
 };
 
-run().catch(core.setFailed);
+export async function downloadHelm(version: string): Promise<string> {
+    if (!version) { version = await getStableHelmVersion(); }
+    let cachedToolpath = toolCache.find(helmToolName, version);
+    if (!cachedToolpath) {
+        let helmDownloadPath;
+        try {
+            helmDownloadPath = await toolCache.downloadTool(getHelmDownloadURL(version));
+        } catch (exception) {
+            throw new Error(util.format("Failed to download Helm from location", getHelmDownloadURL(version)));
+        }
+
+        fs.chmodSync(helmDownloadPath, '777');
+        const unzipedHelmPath = await toolCache.extractZip(helmDownloadPath);
+        cachedToolpath = await toolCache.cacheDir(unzipedHelmPath, helmToolName, version);
+    }
+
+    const helmpath = findHelm(cachedToolpath);
+    if (!helmpath) {
+        throw new Error(util.format("Helm executable not found in path", cachedToolpath));
+    }
+
+    fs.chmodSync(helmpath, '777');
+    return helmpath;
+}
+
+async function getLatestHelmVersionFor(type: string): Promise<string> {
+    const token = core.getInput('token', { 'required': true });
+    try {
+        const { repository } = await graphql(
+            `{
+                repository(name: "helm", owner: "helm") {
+                    releases(last: 100)  {
+                        nodes {
+                            tagName
+                        }
+                    }
+                }
+            }`,
+            {
+                headers: {
+                    authorization: `token ${token}`
+                }
+            }
+        );
+
+        const releases = repository.releases.nodes.reverse();
+        let latestValidRelease = releases.find(release => isValidVersion(release.tagName, type));
+        if (latestValidRelease)
+            return latestValidRelease.tagName;
+    } catch (err) {
+        core.warning(util.format("Error while fetching the latest Helm %s release. Error: %s. Using default Helm version %s.", type, err.toString(), getStableHelmVersionFor(type)));
+        return getStableHelmVersionFor(type);
+    }
+    core.warning(util.format("Could not find stable release for Helm %s. Using default Helm version %s.", type, getStableHelmVersionFor(type)));
+    return getStableHelmVersionFor(type);
+}
+
+function getStableHelmVersionFor(type: string) {
+    return type === "v2" ? stableHelm2Version : stableHelm3Version;
+}
+
+// isValidVersion checks if verison matches the specified type and is a stable release
+function isValidVersion(version: string, type: string): boolean {
+    if (!version.toLocaleLowerCase().startsWith(type))
+        return false;
+    return version.indexOf('rc') == -1;
+}
+
+export function findHelm(rootFolder: string): string {
+    fs.chmodSync(rootFolder, '777');
+    var filelist: string[] = [];
+    walkSync(rootFolder, filelist, helmToolName + getExecutableExtension());
+    if (!filelist || filelist.length == 0) {
+        throw new Error(util.format("Helm executable not found in path", rootFolder));
+    }
+    else {
+        return filelist[0];
+    }
+}
+
+export async function run() {
+    let version = core.getInput('version', { 'required': true });
+
+    if (process.env['HELM_INSTALLER_LEGACY_VERSIONING'] == 'true') {
+        if (version.toLocaleLowerCase() === 'latest') {
+            version = await getStableHelmVersion();
+        } else if (!version.toLocaleLowerCase().startsWith('v')) {
+            version = 'v' + version;
+        }
+    } else {
+        if (version.toLocaleLowerCase() === 'latest' || version === LATEST_HELM3_VERSION) {
+            version = await getLatestHelmVersionFor("v3");
+        } else if (version === LATEST_HELM2_VERSION) {
+            version = await getLatestHelmVersionFor("v2");
+        } else if (!version.toLocaleLowerCase().startsWith('v')) {
+            version = 'v' + version;
+        }
+    }
+
+    core.debug(util.format("Downloading %s", version));
+    let cachedPath = await downloadHelm(version);
+
+    try {
+
+        if (!process.env['PATH'].startsWith(path.dirname(cachedPath))) {
+            core.addPath(path.dirname(cachedPath));
+        }
+    }
+    catch {
+        //do nothing, set as output variable
+    }
+
+    console.log(`Helm tool version: '${version}' has been cached at ${cachedPath}`);
+    core.setOutput('helm-path', cachedPath);
+}
+
+run().catch(core.setFailed);