major: initial implementation of retry step

.commitlintrc.js

@@ -0,0 +1,10 @@
+module.exports = {
+  extends: ['@commitlint/config-conventional'],
+  rules: {
+    'type-enum': [
+      2,
+      'always',
+      ['feat', 'fix', 'docs', 'style', 'refactor', 'test', 'revert', 'patch', 'minor', 'major'],
+    ],
+  },
+};

.github/workflows/ci_cd.yml

@@ -0,0 +1,72 @@
+name: CI/CD
+on:
+  push:
+    branches:
+      - '**'
+jobs:
+  # runs on branch pushes only
+  ci:
+    name: Run Tests
+    if: startsWith(github.ref, 'refs/heads')
+    runs-on: ubuntu-18.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Setup Node.js
+        uses: actions/setup-node@v1
+        with:
+          node-version: 12
+      - name: Install dependencies
+        run: npm ci
+      - name: Test
+        uses: ./
+        continue-on-error: true
+        with:
+          timeout_minutes: 1
+          max_attempts: 3
+          command: npm install this-isnt-a-real-package-name-zzz
+      - name: happy-path
+        uses: ./
+        with:
+          timeout_minutes: 1
+          max_attempts: 2
+          command: npm -v
+      - name: sad-path (error)
+        uses: ./
+        continue-on-error: true
+        with:
+          timeout_minutes: 1
+          max_attempts: 2
+          command: node -e "process.exit(1)"
+      - name: sad-path (timeout)
+        uses: ./
+        continue-on-error: true
+        with:
+          timeout_minutes: 1
+          max_attempts: 2
+          command: node -e "(async()=>await new Promise(r => setTimeout(r, 120000)))()"
+
+  # runs on push to master only
+  cd:
+    name: Publish Action
+    needs: ci
+    if: github.ref == 'refs/heads/master'
+    runs-on: ubuntu-18.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Setup Node.js
+        uses: actions/setup-node@v1
+        with:
+          node-version: 12
+      - name: Install dependencies
+        run: npm ci
+      - name: Release
+        id: release
+        uses: cycjimmy/semantic-release-action@v2
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - name: Tag
+        run: git tag -f zzz && git push origin zzz
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -80,7 +80,6 @@ typings/
 
 # Nuxt.js build / generate output
 .nuxt
-dist
 
 # Gatsby files
 .cache/

.prettierrc.js

@@ -0,0 +1,7 @@
+module.exports = {
+  tabWidth: 2,
+  printWidth: 100,
+  semi: true,
+  singleQuote: true,
+  trailingComma: 'es5',
+};

.releaserc.js

@@ -0,0 +1,22 @@
+module.exports = {
+  plugins: [
+    [
+      '@semantic-release/commit-analyzer',
+      {
+        releaseRules: [
+          { type: 'docs', scope: 'README', release: 'patch' },
+          { type: 'minor', release: 'minor' },
+          { type: 'major', release: 'major' },
+          { type: 'patch', release: 'patch' },
+          { scope: 'no-release', release: false },
+        ],
+      },
+    ],
+    '@semantic-release/release-notes-generator',
+    '@semantic-release/github',
+  ],
+  branches: [
+    { name: 'master' },
+    { name: 'develop', channel: 'develop', prerelease: 'develop' }, // `prerelease` is set to `beta` as it is the value of `name`
+  ],
+};

.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+  "editor.formatOnSave": true,
+  "prettier.requireConfig": true,
+  "typescript.tsdk": "node_modules/typescript/lib",
+  "editor.tabSize": 2
+}

README.md

@@ -1,2 +1,35 @@
-# retry-step
+# retry
-Retries a GitHub Action step on failure or timeout
+
+Retries an Action step on failure or timeout. This is currently intended to replace the `run` step for moody commands.
+
+## Inputs
+
+### `timeout_minutes`
+
+**Required** Minutes to wait before attempt times out
+
+### `max_attempts`
+
+**Required** Number of attempts to make before failing the step
+
+### `command`
+
+**Required** The command to run
+
+### `retry_wait_seconds`
+
+**Optional** Number of seconds to wait before attempting the next retry. Defaults to `10`
+
+### `polling_interval_seconds`
+
+**Optional** Number of seconds to wait while polling for command result. Defaults to `1`
+
+## Example usage
+
+```yaml
+uses: nick-invision/retry@v1
+with:
+  timeout_minutes: 10
+  max_attempts: 3
+  command: npm install
+```

action.yml

@@ -0,0 +1,24 @@
+name: Retry Step
+description: 'Retry a step on failure or timeout'
+inputs:
+  timeout_minutes:
+    description: Minutes to wait before attempt times out
+    required: true
+  max_attempts:
+    description: Number of attempts to make before failing the step
+    required: true
+    default: 3
+  command:
+    description: The command to run
+    required: true
+  retry_wait_seconds:
+    description: Number of seconds to wait before attempting the next retry
+    required: false
+    default: 10
+  polling_interval_seconds:
+    description: Number of seconds to wait for each check that command has completed running
+    required: false
+    default: 1
+runs:
+  using: 'node12'
+  main: 'dist/index.js'

dist/exec.js

@@ -0,0 +1,8 @@
+const { execSync } = require('child_process');
+const COMMAND = process.argv.splice(2)[0];
+
+function run() {
+  execSync(COMMAND, { stdio: 'inherit' });
+}
+
+run();

dist/index.js

@@ -0,0 +1,589 @@
+module.exports =
+/******/ (function(modules, runtime) { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+/******/
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId]) {
+/******/ 			return installedModules[moduleId].exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			i: moduleId,
+/******/ 			l: false,
+/******/ 			exports: {}
+/******/ 		};
+/******/
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ 		// Flag the module as loaded
+/******/ 		module.l = true;
+/******/
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/
+/******/
+/******/ 	__webpack_require__.ab = __dirname + "/";
+/******/
+/******/ 	// the startup function
+/******/ 	function startup() {
+/******/ 		// Load entry module and return exports
+/******/ 		return __webpack_require__(676);
+/******/ 	};
+/******/
+/******/ 	// run startup
+/******/ 	return startup();
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ 87:
+/***/ (function(module) {
+
+module.exports = require("os");
+
+/***/ }),
+
+/***/ 129:
+/***/ (function(module) {
+
+module.exports = require("child_process");
+
+/***/ }),
+
+/***/ 156:
+/***/ (function(module) {
+
+function calc(m) {
+    return function(n) { return Math.round(n * m); };
+};
+module.exports = {
+    seconds: calc(1e3),
+    minutes: calc(6e4),
+    hours: calc(36e5),
+    days: calc(864e5),
+    weeks: calc(6048e5),
+    months: calc(26298e5),
+    years: calc(315576e5)
+};
+
+
+/***/ }),
+
+/***/ 431:
+/***/ (function(__unusedmodule, exports, __webpack_require__) {
+
+"use strict";
+
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const os = __importStar(__webpack_require__(87));
+/**
+ * Commands
+ *
+ * Command Format:
+ *   ::name key=value,key=value::message
+ *
+ * Examples:
+ *   ::warning::This is the message
+ *   ::set-env name=MY_VAR::some value
+ */
+function issueCommand(command, properties, message) {
+    const cmd = new Command(command, properties, message);
+    process.stdout.write(cmd.toString() + os.EOL);
+}
+exports.issueCommand = issueCommand;
+function issue(name, message = '') {
+    issueCommand(name, {}, message);
+}
+exports.issue = issue;
+const CMD_STRING = '::';
+class Command {
+    constructor(command, properties, message) {
+        if (!command) {
+            command = 'missing.command';
+        }
+        this.command = command;
+        this.properties = properties;
+        this.message = message;
+    }
+    toString() {
+        let cmdStr = CMD_STRING + this.command;
+        if (this.properties && Object.keys(this.properties).length > 0) {
+            cmdStr += ' ';
+            let first = true;
+            for (const key in this.properties) {
+                if (this.properties.hasOwnProperty(key)) {
+                    const val = this.properties[key];
+                    if (val) {
+                        if (first) {
+                            first = false;
+                        }
+                        else {
+                            cmdStr += ',';
+                        }
+                        cmdStr += `${key}=${escapeProperty(val)}`;
+                    }
+                }
+            }
+        }
+        cmdStr += `${CMD_STRING}${escapeData(this.message)}`;
+        return cmdStr;
+    }
+}
+function escapeData(s) {
+    return (s || '')
+        .replace(/%/g, '%25')
+        .replace(/\r/g, '%0D')
+        .replace(/\n/g, '%0A');
+}
+function escapeProperty(s) {
+    return (s || '')
+        .replace(/%/g, '%25')
+        .replace(/\r/g, '%0D')
+        .replace(/\n/g, '%0A')
+        .replace(/:/g, '%3A')
+        .replace(/,/g, '%2C');
+}
+//# sourceMappingURL=command.js.map
+
+/***/ }),
+
+/***/ 470:
+/***/ (function(__unusedmodule, exports, __webpack_require__) {
+
+"use strict";
+
+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());
+    });
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = __webpack_require__(431);
+const os = __importStar(__webpack_require__(87));
+const path = __importStar(__webpack_require__(622));
+/**
+ * The code to exit an action
+ */
+var ExitCode;
+(function (ExitCode) {
+    /**
+     * A code indicating that the action was successful
+     */
+    ExitCode[ExitCode["Success"] = 0] = "Success";
+    /**
+     * A code indicating that the action was a failure
+     */
+    ExitCode[ExitCode["Failure"] = 1] = "Failure";
+})(ExitCode = exports.ExitCode || (exports.ExitCode = {}));
+//-----------------------------------------------------------------------
+// Variables
+//-----------------------------------------------------------------------
+/**
+ * Sets env variable for this action and future actions in the job
+ * @param name the name of the variable to set
+ * @param val the value of the variable
+ */
+function exportVariable(name, val) {
+    process.env[name] = val;
+    command_1.issueCommand('set-env', { name }, val);
+}
+exports.exportVariable = exportVariable;
+/**
+ * Registers a secret which will get masked from logs
+ * @param secret value of the secret
+ */
+function setSecret(secret) {
+    command_1.issueCommand('add-mask', {}, secret);
+}
+exports.setSecret = setSecret;
+/**
+ * Prepends inputPath to the PATH (for this action and future actions)
+ * @param inputPath
+ */
+function addPath(inputPath) {
+    command_1.issueCommand('add-path', {}, inputPath);
+    process.env['PATH'] = `${inputPath}${path.delimiter}${process.env['PATH']}`;
+}
+exports.addPath = addPath;
+/**
+ * Gets the value of an input.  The value is also trimmed.
+ *
+ * @param     name     name of the input to get
+ * @param     options  optional. See InputOptions.
+ * @returns   string
+ */
+function getInput(name, options) {
+    const val = process.env[`INPUT_${name.replace(/ /g, '_').toUpperCase()}`] || '';
+    if (options && options.required && !val) {
+        throw new Error(`Input required and not supplied: ${name}`);
+    }
+    return val.trim();
+}
+exports.getInput = getInput;
+/**
+ * Sets the value of an output.
+ *
+ * @param     name     name of the output to set
+ * @param     value    value to store
+ */
+function setOutput(name, value) {
+    command_1.issueCommand('set-output', { name }, value);
+}
+exports.setOutput = setOutput;
+//-----------------------------------------------------------------------
+// Results
+//-----------------------------------------------------------------------
+/**
+ * Sets the action status to failed.
+ * When the action exits it will be with an exit code of 1
+ * @param message add error issue message
+ */
+function setFailed(message) {
+    process.exitCode = ExitCode.Failure;
+    error(message);
+}
+exports.setFailed = setFailed;
+//-----------------------------------------------------------------------
+// Logging Commands
+//-----------------------------------------------------------------------
+/**
+ * Writes debug message to user log
+ * @param message debug message
+ */
+function debug(message) {
+    command_1.issueCommand('debug', {}, message);
+}
+exports.debug = debug;
+/**
+ * Adds an error issue
+ * @param message error issue message
+ */
+function error(message) {
+    command_1.issue('error', message);
+}
+exports.error = error;
+/**
+ * Adds an warning issue
+ * @param message warning issue message
+ */
+function warning(message) {
+    command_1.issue('warning', message);
+}
+exports.warning = warning;
+/**
+ * Writes info to log with console.log.
+ * @param message info message
+ */
+function info(message) {
+    process.stdout.write(message + os.EOL);
+}
+exports.info = info;
+/**
+ * Begin an output group.
+ *
+ * Output until the next `groupEnd` will be foldable in this group
+ *
+ * @param name The name of the output group
+ */
+function startGroup(name) {
+    command_1.issue('group', name);
+}
+exports.startGroup = startGroup;
+/**
+ * End an output group.
+ */
+function endGroup() {
+    command_1.issue('endgroup');
+}
+exports.endGroup = endGroup;
+/**
+ * Wrap an asynchronous function call in a group.
+ *
+ * Returns the same type as the function itself.
+ *
+ * @param name The name of the group
+ * @param fn The function to wrap in the group
+ */
+function group(name, fn) {
+    return __awaiter(this, void 0, void 0, function* () {
+        startGroup(name);
+        let result;
+        try {
+            result = yield fn();
+        }
+        finally {
+            endGroup();
+        }
+        return result;
+    });
+}
+exports.group = group;
+//-----------------------------------------------------------------------
+// Wrapper action state
+//-----------------------------------------------------------------------
+/**
+ * Saves state for current action, the state can only be retrieved by this action's post job execution.
+ *
+ * @param     name     name of the state to store
+ * @param     value    value to store
+ */
+function saveState(name, value) {
+    command_1.issueCommand('save-state', { name }, value);
+}
+exports.saveState = saveState;
+/**
+ * Gets the value of an state set by this action's main execution.
+ *
+ * @param     name     name of the state to get
+ * @returns   string
+ */
+function getState(name) {
+    return process.env[`STATE_${name}`] || '';
+}
+exports.getState = getState;
+//# sourceMappingURL=core.js.map
+
+/***/ }),
+
+/***/ 622:
+/***/ (function(module) {
+
+module.exports = require("path");
+
+/***/ }),
+
+/***/ 676:
+/***/ (function(__unusedmodule, __unusedexports, __webpack_require__) {
+
+const { getInput, error, warning, info } = __webpack_require__(470);
+const { spawn } = __webpack_require__(129);
+const { join } = __webpack_require__(622);
+const ms = __webpack_require__(156);
+var kill = __webpack_require__(791);
+
+function getInputNumber(id, required) {
+  const input = getInput(id, { required });
+  const num = Number.parseInt(input);
+
+  if (!Number.isInteger(num)) {
+    throw `Input ${id} only accepts numbers.  Received ${input}`;
+  }
+
+  return num;
+}
+
+// inputs
+const TIMEOUT_MINUTES = getInputNumber('timeout_minutes', true);
+const MAX_ATTEMPTS = getInputNumber('max_attempts', true);
+const COMMAND = getInput('command', { required: true });
+const RETRY_WAIT_SECONDS = getInputNumber('retry_wait_seconds', false);
+const POLLING_INTERVAL_SECONDS = getInputNumber('polling_interval_seconds', false);
+
+async function wait(ms) {
+  return new Promise(r => setTimeout(r, ms));
+}
+
+async function runCmd() {
+  const end_time = Date.now() + ms.minutes(TIMEOUT_MINUTES);
+  var done, exit;
+
+  var child = spawn('node', [__webpack_require__.ab + "exec.js", COMMAND], { stdio: 'inherit' });
+
+  child.on('exit', code => {
+    if (code > 0) {
+      exit = code;
+    }
+    done = true;
+  });
+
+  do {
+    await wait(ms.seconds(POLLING_INTERVAL_SECONDS));
+  } while (Date.now() < end_time && !done && !exit);
+
+  if (!done) {
+    kill(child.pid);
+    await wait(ms.seconds(RETRY_WAIT_SECONDS));
+    throw new Error(`Timeout of ${TIMEOUT_MINUTES}m hit`);
+  } else if (exit > 0) {
+    throw new Error(`Child_process exited with error`);
+  } else {
+    return;
+  }
+}
+
+async function runAction() {
+  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+    try {
+      await runCmd();
+      info(`Command completed after ${attempt} attempt(s).`);
+      break;
+    } catch (error) {
+      if (attempt === MAX_ATTEMPTS) {
+        throw new Error(`Final attempt failed. ${error.message}`);
+      } else {
+        warning(`Attempt ${attempt} failed. Reason:`, error.message);
+      }
+    }
+  }
+}
+
+runAction().catch(err => {
+  error(err.message);
+  process.exit(1);
+});
+
+
+/***/ }),
+
+/***/ 791:
+/***/ (function(module, __unusedexports, __webpack_require__) {
+
+"use strict";
+
+
+var childProcess = __webpack_require__(129);
+var spawn = childProcess.spawn;
+var exec = childProcess.exec;
+
+module.exports = function (pid, signal, callback) {
+    if (typeof signal === 'function' && callback === undefined) {
+        callback = signal;
+        signal = undefined;
+    }
+
+    pid = parseInt(pid);
+    if (Number.isNaN(pid)) {
+        if (callback) {
+            return callback(new Error("pid must be a number"));
+        } else {
+            throw new Error("pid must be a number");
+        }
+    }
+
+    var tree = {};
+    var pidsToProcess = {};
+    tree[pid] = [];
+    pidsToProcess[pid] = 1;
+
+    switch (process.platform) {
+    case 'win32':
+        exec('taskkill /pid ' + pid + ' /T /F', callback);
+        break;
+    case 'darwin':
+        buildProcessTree(pid, tree, pidsToProcess, function (parentPid) {
+          return spawn('pgrep', ['-P', parentPid]);
+        }, function () {
+            killAll(tree, signal, callback);
+        });
+        break;
+    // case 'sunos':
+    //     buildProcessTreeSunOS(pid, tree, pidsToProcess, function () {
+    //         killAll(tree, signal, callback);
+    //     });
+    //     break;
+    default: // Linux
+        buildProcessTree(pid, tree, pidsToProcess, function (parentPid) {
+          return spawn('ps', ['-o', 'pid', '--no-headers', '--ppid', parentPid]);
+        }, function () {
+            killAll(tree, signal, callback);
+        });
+        break;
+    }
+};
+
+function killAll (tree, signal, callback) {
+    var killed = {};
+    try {
+        Object.keys(tree).forEach(function (pid) {
+            tree[pid].forEach(function (pidpid) {
+                if (!killed[pidpid]) {
+                    killPid(pidpid, signal);
+                    killed[pidpid] = 1;
+                }
+            });
+            if (!killed[pid]) {
+                killPid(pid, signal);
+                killed[pid] = 1;
+            }
+        });
+    } catch (err) {
+        if (callback) {
+            return callback(err);
+        } else {
+            throw err;
+        }
+    }
+    if (callback) {
+        return callback();
+    }
+}
+
+function killPid(pid, signal) {
+    try {
+        process.kill(parseInt(pid, 10), signal);
+    }
+    catch (err) {
+        if (err.code !== 'ESRCH') throw err;
+    }
+}
+
+function buildProcessTree (parentPid, tree, pidsToProcess, spawnChildProcessesList, cb) {
+    var ps = spawnChildProcessesList(parentPid);
+    var allData = '';
+    ps.stdout.on('data', function (data) {
+        var data = data.toString('ascii');
+        allData += data;
+    });
+
+    var onClose = function (code) {
+        delete pidsToProcess[parentPid];
+
+        if (code != 0) {
+            // no more parent processes
+            if (Object.keys(pidsToProcess).length == 0) {
+                cb();
+            }
+            return;
+        }
+
+        allData.match(/\d+/g).forEach(function (pid) {
+          pid = parseInt(pid, 10);
+          tree[parentPid].push(pid);
+          tree[pid] = [];
+          pidsToProcess[pid] = 1;
+          buildProcessTree(pid, tree, pidsToProcess, spawnChildProcessesList, cb);
+        });
+    };
+
+    ps.on('close', onClose);
+}
+
+
+/***/ })
+
+/******/ });

package.json

@@ -0,0 +1,39 @@
+{
+  "name": "retry",
+  "version": "0.0.0-managed-by-semantic-release",
+  "description": "Retries a GitHub Action step on failure or timeout.",
+  "scripts": {
+    "prepare": "ncc build src/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nick-invision/retry.git"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/nick-invision/retry/issues"
+  },
+  "homepage": "https://github.com/nick-invision/retry#readme",
+  "dependencies": {
+    "@actions/core": "^1.2.0",
+    "milliseconds": "^1.0.3",
+    "tree-kill": "^1.2.2"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^8.3.5",
+    "@commitlint/config-conventional": "^8.3.4",
+    "@semantic-release/changelog": "^3.0.6",
+    "@semantic-release/git": "^7.0.18",
+    "@zeit/ncc": "^0.20.5",
+    "husky": "^3.1.0",
+    "semantic-release": "^17.0.3"
+  },
+  "husky": {
+    "hooks": {
+      "commit-msg": "commitlint -E HUSKY_GIT_PARAMS",
+      "pre-commit": "npm run prepare && git add ."
+    }
+  }
+}

src/exec.js

@@ -0,0 +1,8 @@
+const { execSync } = require('child_process');
+const COMMAND = process.argv.splice(2)[0];
+
+function run() {
+  execSync(COMMAND, { stdio: 'inherit' });
+}
+
+run();

src/index.js

@@ -0,0 +1,76 @@
+const { getInput, error, warning, info } = require('@actions/core');
+const { spawn } = require('child_process');
+const { join } = require('path');
+const ms = require('milliseconds');
+var kill = require('tree-kill');
+
+function getInputNumber(id, required) {
+  const input = getInput(id, { required });
+  const num = Number.parseInt(input);
+
+  if (!Number.isInteger(num)) {
+    throw `Input ${id} only accepts numbers.  Received ${input}`;
+  }
+
+  return num;
+}
+
+// inputs
+const TIMEOUT_MINUTES = getInputNumber('timeout_minutes', true);
+const MAX_ATTEMPTS = getInputNumber('max_attempts', true);
+const COMMAND = getInput('command', { required: true });
+const RETRY_WAIT_SECONDS = getInputNumber('retry_wait_seconds', false);
+const POLLING_INTERVAL_SECONDS = getInputNumber('polling_interval_seconds', false);
+
+async function wait(ms) {
+  return new Promise(r => setTimeout(r, ms));
+}
+
+async function runCmd() {
+  const end_time = Date.now() + ms.minutes(TIMEOUT_MINUTES);
+  var done, exit;
+
+  var child = spawn('node', [join(__dirname, 'exec.js'), COMMAND], { stdio: 'inherit' });
+
+  child.on('exit', code => {
+    if (code > 0) {
+      exit = code;
+    }
+    done = true;
+  });
+
+  do {
+    await wait(ms.seconds(POLLING_INTERVAL_SECONDS));
+  } while (Date.now() < end_time && !done && !exit);
+
+  if (!done) {
+    kill(child.pid);
+    await wait(ms.seconds(RETRY_WAIT_SECONDS));
+    throw new Error(`Timeout of ${TIMEOUT_MINUTES}m hit`);
+  } else if (exit > 0) {
+    throw new Error(`Child_process exited with error`);
+  } else {
+    return;
+  }
+}
+
+async function runAction() {
+  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+    try {
+      await runCmd();
+      info(`Command completed after ${attempt} attempt(s).`);
+      break;
+    } catch (error) {
+      if (attempt === MAX_ATTEMPTS) {
+        throw new Error(`Final attempt failed. ${error.message}`);
+      } else {
+        warning(`Attempt ${attempt} failed. Reason:`, error.message);
+      }
+    }
+  }
+}
+
+runAction().catch(err => {
+  error(err.message);
+  process.exit(1);
+});