The purpose of this library is - build simple and flexible interface for parallel command execution with rerun (on fail) possibility

Usage no npm install needed!

<script type="module">
  import processRerun from '';



The purpose of this library is - build simple and flexible interface for parallel command execution with rerun (on fail) possibility

npm downloads




buildRunner(buildOpts): returns rerunner: function(string[]): {retriable: string[]; notRetriable: string[]}

arguments description
buildOpts Type: object
Options for executor
buildOpts.maxThreads Optional Type: number,
How many threads can be executed in same time
Default threads count is 5
buildOpts.intime Optional Type: boolean,
if intime is true intime execution approach will be enabled
Default is false
buildOpts.shuffle Optional Type: boolean,
Shuffle commands during execution
Default threads count is 5
buildOpts.attemptsCount Optional Type: number,
How many times can we try to execute command for success result in next cycle will be executed only faild command, success commands will not be reexecuted
Default attempts count is 2
buildOpts.pollTime Optional Type: number,
Period for recheck about free thread
Default is 1 second
buildOpts.successExitCode Optional Type: number,
Exit code what will be used for succes process check
Default is 0
buildOpts.logLevel Type: string, one of 'ERROR', 'WARN', 'INFO', 'VERBOSE', 'MUTE'
ERROR - only errors, WARN - errors and warnings, INFO - errors, warnings and information, VERBOSE - full logging, MUTE - mute execution output
Default is 'ERROR'
buildOpts.currentExecutionVariable Optional Type: string, will be execution variable with execution index for every cycle will be ++
buildOpts.everyCycleCallback Optional Type: function,
Optional. everyCycleCallback will be executed after cycle, before next execution cycle.
Default is false
buildOpts.processResultAnalyzer Optional Type: function,
Optional. processResultAnalyzer is a function where arguments are original command, execution stack trace and notRetriable array processResultAnalyzer should return a new command what will be executed in next cycle or null - if satisfactory result
buildOpts.longestProcessTime Optional Type: number,
In case if command execution time is longer than longest Process Time - executor will kill it automatically and will try to execute this command again.
Default time is 45 seconds


const {buildRunner} = require('process-rerun');

async function execCommands() {
  const runner = buildRunner({
    maxThreads: 10,               // ten threads
    attemptsCount: 2,             // will try to pass all commands two times, one main and one times rerun
    longestProcessTime: 60 * 1000,// if command process execution time is longre than 1 minute will kill it and try to pass in next cycle
    pollTime: 1000,               // will check free thread every second
    everyCycleCallback: () => console.log('Cycle done'),
    processResultAnalyzer: (cmd, stackTrace, notRetriableArr) => {
      if (stackTrace.includes('Should be re executed')) {
        return cmd;
    }, //true - command will be reexecuted
  const result = await runner([
    `node -e 'console.log("Success first")'`,
    `node -e 'console.log("Success second")'`,
    `node -e 'console.log("Failed first"); process.exit(1)'`,
    `node -e 'console.log("Success third")'`,
    `node -e 'console.log("Failed second"); process.exit(1)'`,

    retriable: [
      `node -e 'console.log("Failed first"); process.exit(1)' --opt1=opt1value --opt1=opt1value`,
      `node -e 'console.log("Failed second"); process.exit(1)' --opt1=opt1value --opt1=opt1value`
    notRetriable: []


arguments description
dir Type: string , required
Directory what will be used as a root
fileList Type: Array<string> ,
This array will be used as a target for push new file
directoryToSkip Type: Array<string>|string|regex,
Exlude some directory
ignoreSubDirs Type: boolean,
In case of true - sub directories will be ignored

usage exampele

const {getFilesList} = require('process-rerun');

const readmePath = getFilesList(__dirname).find((filePath) => filePath.include(''));

intime approach vs circle approach

circle approach

five processes execution, two execution attempts, five parallel execution

first execution attempt (three failed) second execution attempt (one failed) third execution attempt (o failed)
1 p1 --------------------------> success p2 ---> success p4 -----------> success
2 p2 ---> fail p4 -----------> fail
3 p3 -------> fail p3 -------> success
4 p4 -----------> fail
5 p5 -----> success

Full execution time:
p1 (first attempt) --------------------------> + p4 (second attempt) -----------> + (third attempt) p4 ----------->

intime approach (with same fail scheme)

every process has attemp count timer

f - fail
s - success
1 p1 -------------------------->s
2 p2 --->f--->s
3 p3 ------->f------->s
4 p4 ----------->f
5 p5 ----->s(p4)----------->f----------->s

Full execution time:

5 p5 ----->s(p4)----------->f----------->s

Failed process will check that free parallel exists and start execution when free parallel will be found.


Version 0.1.11