azure-pipelines-task-lib 5.0.1-preview.0 → 5.2.0

package/toolrunner.d.ts

@@ -1,4 +1,6 @@
 /// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
 import Q = require('q');
 import events = require('events');
 /**
@@ -94,6 +96,7 @@ export declare class ToolRunner extends events.EventEmitter {
     private _cloneExecOptions;
     private _getSpawnOptions;
     private _getSpawnSyncOptions;
+    private execWithPipingAsync;
     private execWithPiping;
     /**
      * Add argument
@@ -139,6 +142,17 @@ export declare class ToolRunner extends events.EventEmitter {
      * @param     options  optional exec options.  See IExecOptions
      * @returns   number
      */
+    execAsync(options?: IExecOptions): Promise<number>;
+    /**
+     * Exec a tool.
+     * Output will be streamed to the live console.
+     * Returns promise with return code
+     *
+     * @deprecated Use the `execAsync` method that returns a native Javascript promise instead
+     * @param     tool     path to tool to exec
+     * @param     options  optional exec options.  See IExecOptions
+     * @returns   number
+     */
     exec(options?: IExecOptions): Q.Promise<number>;
     /**
      * Exec a tool synchronously.
@@ -155,5 +169,5 @@ export declare class ToolRunner extends events.EventEmitter {
      * Used to close child process by sending SIGNINT signal.
      * It allows executed script to have some additional logic on SIGINT, before exiting.
      */
-    killChildProcess(): void;
+    killChildProcess(signal?: number | NodeJS.Signals): void;
 }

package/toolrunner.js

@@ -7,6 +7,8 @@ var __extends = (this && this.__extends) || (function () {
         return extendStatics(d, b);
     };
     return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
         extendStatics(d, b);
         function __() { this.constructor = d; }
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
@@ -107,7 +109,7 @@ var ToolRunner = /** @class */ (function (_super) {
             }
             // Windows + verbatim
             else if (options.windowsVerbatimArguments) {
-                commandParts.push("\"" + toolPath + "\"");
+                commandParts.push("\"".concat(toolPath, "\""));
                 commandParts = commandParts.concat(args);
             }
             else if (options.shell) {
@@ -134,23 +136,23 @@ var ToolRunner = /** @class */ (function (_super) {
         }
         return cmd;
     };
-    ToolRunner.prototype._processLineBuffer = function (data, strBuffer, onLine) {
+    ToolRunner.prototype._processLineBuffer = function (data, buffer, onLine) {
+        var newBuffer = buffer + data.toString();
         try {
-            var s = strBuffer + data.toString();
-            var n = s.indexOf(os.EOL);
-            while (n > -1) {
-                var line = s.substring(0, n);
+            var eolIndex = newBuffer.indexOf(os.EOL);
+            while (eolIndex > -1) {
+                var line = newBuffer.substring(0, eolIndex);
                 onLine(line);
                 // the rest of the string ...
-                s = s.substring(n + os.EOL.length);
-                n = s.indexOf(os.EOL);
+                newBuffer = newBuffer.substring(eolIndex + os.EOL.length);
+                eolIndex = newBuffer.indexOf(os.EOL);
             }
-            strBuffer = s;
         }
         catch (err) {
             // streaming lines to console is best effort.  Don't fail a build.
             this._debug('error processing line');
         }
+        return newBuffer;
     };
     /**
      * Wraps an arg string with specified char if it's not already wrapped
@@ -160,7 +162,7 @@ var ToolRunner = /** @class */ (function (_super) {
      */
     ToolRunner.prototype._wrapArg = function (arg, wrapChar) {
         if (!this._isWrapped(arg, wrapChar)) {
-            return "" + wrapChar + arg + wrapChar;
+            return "".concat(wrapChar).concat(arg).concat(wrapChar);
         }
         return arg;
     };
@@ -171,7 +173,7 @@ var ToolRunner = /** @class */ (function (_super) {
      */
     ToolRunner.prototype._unwrapArg = function (arg, wrapChar) {
         if (this._isWrapped(arg, wrapChar)) {
-            var pattern = new RegExp("(^\\\\?" + wrapChar + ")|(\\\\?" + wrapChar + "$)", 'g');
+            var pattern = new RegExp("(^\\\\?".concat(wrapChar, ")|(\\\\?").concat(wrapChar, "$)"), 'g');
             return arg.trim().replace(pattern, '');
         }
         return arg;
@@ -181,7 +183,7 @@ var ToolRunner = /** @class */ (function (_super) {
      * @param arg Input arg string
      */
     ToolRunner.prototype._isWrapped = function (arg, wrapChar) {
-        var pattern = new RegExp("^\\\\?" + wrapChar + ".+\\\\?" + wrapChar + "$");
+        var pattern = new RegExp("^\\\\?".concat(wrapChar, ".+\\\\?").concat(wrapChar, "$"));
         return pattern.test(arg.trim());
     };
     ToolRunner.prototype._getSpawnFileName = function (options) {
@@ -199,7 +201,7 @@ var ToolRunner = /** @class */ (function (_super) {
         var _this = this;
         if (process.platform == 'win32') {
             if (this._isCmdFile()) {
-                var argline = "/D /S /C \"" + this._windowsQuoteCmdArg(this.toolPath);
+                var argline = "/D /S /C \"".concat(this._windowsQuoteCmdArg(this.toolPath));
                 for (var i = 0; i < this.args.length; i++) {
                     argline += ' ';
                     argline += options.windowsVerbatimArguments ? this.args[i] : this._windowsQuoteCmdArg(this.args[i]);
@@ -243,7 +245,7 @@ var ToolRunner = /** @class */ (function (_super) {
                     if (arguments.length != 1) {
                         throw new Error('Unexpected arguments passed to args.unshift when windowsVerbatimArguments flag is set.');
                     }
-                    return Array.prototype.unshift.call(args_1, "\"" + arguments[0] + "\""); // quote the file name
+                    return Array.prototype.unshift.call(args_1, "\"".concat(arguments[0], "\"")); // quote the file name
                 };
                 return args_1;
             }
@@ -447,7 +449,7 @@ var ToolRunner = /** @class */ (function (_super) {
         if (arg.indexOf('"') < 0 && arg.indexOf('\\') < 0) {
             // No embedded double quotes or backslashes, so I can just wrap
             // quote marks around the whole thing.
-            return "\"" + arg + "\"";
+            return "\"".concat(arg, "\"");
         }
         // Expected input/output:
         //   input : hello"world
@@ -516,6 +518,186 @@ var ToolRunner = /** @class */ (function (_super) {
         result['windowsVerbatimArguments'] = options.windowsVerbatimArguments || this._isCmdFile();
         return result;
     };
+    ToolRunner.prototype.execWithPipingAsync = function (pipeOutputToTool, options) {
+        var _this = this;
+        this._debug('exec tool: ' + this.toolPath);
+        this._debug('arguments:');
+        this.args.forEach(function (arg) {
+            _this._debug('   ' + arg);
+        });
+        var success = true;
+        var optionsNonNull = this._cloneExecOptions(options);
+        if (!optionsNonNull.silent) {
+            optionsNonNull.outStream.write(this._getCommandString(optionsNonNull) + os.EOL);
+        }
+        var cp;
+        var toolPath = pipeOutputToTool.toolPath;
+        var toolPathFirst;
+        var successFirst = true;
+        var returnCodeFirst;
+        var fileStream;
+        var waitingEvents = 0; // number of process or stream events we are waiting on to complete
+        var returnCode = 0;
+        var error;
+        toolPathFirst = this.toolPath;
+        // Following node documentation example from this link on how to pipe output of one process to another
+        // https://nodejs.org/api/child_process.html#child_process_child_process_spawn_command_args_options
+        //start the child process for both tools
+        waitingEvents++;
+        var cpFirst = child.spawn(this._getSpawnFileName(optionsNonNull), this._getSpawnArgs(optionsNonNull), this._getSpawnOptions(optionsNonNull));
+        waitingEvents++;
+        cp = child.spawn(pipeOutputToTool._getSpawnFileName(optionsNonNull), pipeOutputToTool._getSpawnArgs(optionsNonNull), pipeOutputToTool._getSpawnOptions(optionsNonNull));
+        fileStream = this.pipeOutputToFile ? fs.createWriteStream(this.pipeOutputToFile) : null;
+        return new Promise(function (resolve, reject) {
+            var _a, _b, _c, _d;
+            if (fileStream) {
+                waitingEvents++;
+                fileStream.on('finish', function () {
+                    waitingEvents--; //file write is complete
+                    fileStream = null;
+                    if (waitingEvents == 0) {
+                        if (error) {
+                            reject(error);
+                        }
+                        else {
+                            resolve(returnCode);
+                        }
+                    }
+                });
+                fileStream.on('error', function (err) {
+                    waitingEvents--; //there were errors writing to the file, write is done
+                    _this._debug("Failed to pipe output of ".concat(toolPathFirst, " to file ").concat(_this.pipeOutputToFile, ". Error = ").concat(err));
+                    fileStream = null;
+                    if (waitingEvents == 0) {
+                        if (error) {
+                            reject(error);
+                        }
+                        else {
+                            resolve(returnCode);
+                        }
+                    }
+                });
+            }
+            //pipe stdout of first tool to stdin of second tool
+            (_a = cpFirst.stdout) === null || _a === void 0 ? void 0 : _a.on('data', function (data) {
+                var _a, _b;
+                try {
+                    if (fileStream) {
+                        fileStream.write(data);
+                    }
+                    if (!((_a = cp.stdin) === null || _a === void 0 ? void 0 : _a.destroyed)) {
+                        (_b = cp.stdin) === null || _b === void 0 ? void 0 : _b.write(data);
+                    }
+                }
+                catch (err) {
+                    _this._debug('Failed to pipe output of ' + toolPathFirst + ' to ' + toolPath);
+                    _this._debug(toolPath + ' might have exited due to errors prematurely. Verify the arguments passed are valid.');
+                }
+            });
+            (_b = cpFirst.stderr) === null || _b === void 0 ? void 0 : _b.on('data', function (data) {
+                if (fileStream) {
+                    fileStream.write(data);
+                }
+                successFirst = !optionsNonNull.failOnStdErr;
+                if (!optionsNonNull.silent) {
+                    var s = optionsNonNull.failOnStdErr ? optionsNonNull.errStream : optionsNonNull.outStream;
+                    s.write(data);
+                }
+            });
+            cpFirst.on('error', function (err) {
+                var _a;
+                waitingEvents--; //first process is complete with errors
+                if (fileStream) {
+                    fileStream.end();
+                }
+                (_a = cp.stdin) === null || _a === void 0 ? void 0 : _a.end();
+                error = new Error(toolPathFirst + ' failed. ' + err.message);
+                if (waitingEvents == 0) {
+                    reject(error);
+                }
+            });
+            cpFirst.on('close', function (code, signal) {
+                var _a;
+                waitingEvents--; //first process is complete
+                if (code != 0 && !optionsNonNull.ignoreReturnCode) {
+                    successFirst = false;
+                    returnCodeFirst = code;
+                    returnCode = returnCodeFirst;
+                }
+                _this._debug('success of first tool:' + successFirst);
+                if (fileStream) {
+                    fileStream.end();
+                }
+                (_a = cp.stdin) === null || _a === void 0 ? void 0 : _a.end();
+                if (waitingEvents == 0) {
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        resolve(returnCode);
+                    }
+                }
+            });
+            var stdLineBuffer = '';
+            (_c = cp.stdout) === null || _c === void 0 ? void 0 : _c.on('data', function (data) {
+                _this.emit('stdout', data);
+                if (!optionsNonNull.silent) {
+                    optionsNonNull.outStream.write(data);
+                }
+                stdLineBuffer = _this._processLineBuffer(data, stdLineBuffer, function (line) {
+                    _this.emit('stdline', line);
+                });
+            });
+            var errLineBuffer = '';
+            (_d = cp.stderr) === null || _d === void 0 ? void 0 : _d.on('data', function (data) {
+                _this.emit('stderr', data);
+                success = !optionsNonNull.failOnStdErr;
+                if (!optionsNonNull.silent) {
+                    var s = optionsNonNull.failOnStdErr ? optionsNonNull.errStream : optionsNonNull.outStream;
+                    s.write(data);
+                }
+                errLineBuffer = _this._processLineBuffer(data, errLineBuffer, function (line) {
+                    _this.emit('errline', line);
+                });
+            });
+            cp.on('error', function (err) {
+                waitingEvents--; //process is done with errors
+                error = new Error(toolPath + ' failed. ' + err.message);
+                if (waitingEvents == 0) {
+                    reject(error);
+                }
+            });
+            cp.on('close', function (code, signal) {
+                waitingEvents--; //process is complete
+                _this._debug('rc:' + code);
+                returnCode = code;
+                if (stdLineBuffer.length > 0) {
+                    _this.emit('stdline', stdLineBuffer);
+                }
+                if (errLineBuffer.length > 0) {
+                    _this.emit('errline', errLineBuffer);
+                }
+                if (code != 0 && !optionsNonNull.ignoreReturnCode) {
+                    success = false;
+                }
+                _this._debug('success:' + success);
+                if (!successFirst) { //in the case output is piped to another tool, check exit code of both tools
+                    error = new Error(toolPathFirst + ' failed with return code: ' + returnCodeFirst);
+                }
+                else if (!success) {
+                    error = new Error(toolPath + ' failed with return code: ' + code);
+                }
+                if (waitingEvents == 0) {
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        resolve(returnCode);
+                    }
+                }
+            });
+        });
+    };
     ToolRunner.prototype.execWithPiping = function (pipeOutputToTool, options) {
         var _this = this;
         var _a, _b, _c, _d;
@@ -564,7 +746,7 @@ var ToolRunner = /** @class */ (function (_super) {
             });
             fileStream.on('error', function (err) {
                 waitingEvents--; //there were errors writing to the file, write is done
-                _this._debug("Failed to pipe output of " + toolPathFirst + " to file " + _this.pipeOutputToFile + ". Error = " + err);
+                _this._debug("Failed to pipe output of ".concat(toolPathFirst, " to file ").concat(_this.pipeOutputToFile, ". Error = ").concat(err));
                 fileStream = null;
                 if (waitingEvents == 0) {
                     if (error) {
@@ -634,17 +816,17 @@ var ToolRunner = /** @class */ (function (_super) {
                 }
             }
         });
-        var stdbuffer = '';
+        var stdLineBuffer = '';
         (_c = cp.stdout) === null || _c === void 0 ? void 0 : _c.on('data', function (data) {
             _this.emit('stdout', data);
             if (!optionsNonNull.silent) {
                 optionsNonNull.outStream.write(data);
             }
-            _this._processLineBuffer(data, stdbuffer, function (line) {
+            stdLineBuffer = _this._processLineBuffer(data, stdLineBuffer, function (line) {
                 _this.emit('stdline', line);
             });
         });
-        var errbuffer = '';
+        var errLineBuffer = '';
         (_d = cp.stderr) === null || _d === void 0 ? void 0 : _d.on('data', function (data) {
             _this.emit('stderr', data);
             success = !optionsNonNull.failOnStdErr;
@@ -652,7 +834,7 @@ var ToolRunner = /** @class */ (function (_super) {
                 var s = optionsNonNull.failOnStdErr ? optionsNonNull.errStream : optionsNonNull.outStream;
                 s.write(data);
             }
-            _this._processLineBuffer(data, errbuffer, function (line) {
+            errLineBuffer = _this._processLineBuffer(data, errLineBuffer, function (line) {
                 _this.emit('errline', line);
             });
         });
@@ -667,11 +849,11 @@ var ToolRunner = /** @class */ (function (_super) {
             waitingEvents--; //process is complete
             _this._debug('rc:' + code);
             returnCode = code;
-            if (stdbuffer.length > 0) {
-                _this.emit('stdline', stdbuffer);
+            if (stdLineBuffer.length > 0) {
+                _this.emit('stdline', stdLineBuffer);
             }
-            if (errbuffer.length > 0) {
-                _this.emit('errline', errbuffer);
+            if (errLineBuffer.length > 0) {
+                _this.emit('errline', errLineBuffer);
             }
             if (code != 0 && !optionsNonNull.ignoreReturnCode) {
                 success = false;
@@ -767,13 +949,12 @@ var ToolRunner = /** @class */ (function (_super) {
      * @param     options  optional exec options.  See IExecOptions
      * @returns   number
      */
-    ToolRunner.prototype.exec = function (options) {
+    ToolRunner.prototype.execAsync = function (options) {
         var _this = this;
         var _a, _b, _c;
         if (this.pipeOutputToTool) {
-            return this.execWithPiping(this.pipeOutputToTool, options);
+            return this.execWithPipingAsync(this.pipeOutputToTool, options);
         }
-        var defer = Q.defer();
         this._debug('exec tool: ' + this.toolPath);
         this._debug('arguments:');
         this.args.forEach(function (arg) {
@@ -787,7 +968,41 @@ var ToolRunner = /** @class */ (function (_super) {
         state.on('debug', function (message) {
             _this._debug(message);
         });
-        var cp = child.spawn(this._getSpawnFileName(options), this._getSpawnArgs(optionsNonNull), this._getSpawnOptions(options));
+        var stdLineBuffer = '';
+        var errLineBuffer = '';
+        var emitDoneEvent = function (resolve, reject) {
+            state.on('done', function (error, exitCode) {
+                if (stdLineBuffer.length > 0) {
+                    _this.emit('stdline', stdLineBuffer);
+                }
+                if (errLineBuffer.length > 0) {
+                    _this.emit('errline', errLineBuffer);
+                }
+                if (cp) {
+                    cp.removeAllListeners();
+                }
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve(exitCode);
+                }
+            });
+        };
+        // Edge case when the node itself cant's spawn and emit event
+        var cp;
+        try {
+            cp = child.spawn(this._getSpawnFileName(options), this._getSpawnArgs(optionsNonNull), this._getSpawnOptions(options));
+        }
+        catch (error) {
+            return new Promise(function (resolve, reject) {
+                emitDoneEvent(resolve, reject);
+                state.processError = error.message;
+                state.processExited = true;
+                state.processClosed = true;
+                state.CheckComplete();
+            });
+        }
         this.childProcess = cp;
         // it is possible for the child process to end its last line without a new line.
         // because stdout is buffered, this causes the last line to not get sent to the parent
@@ -797,17 +1012,15 @@ var ToolRunner = /** @class */ (function (_super) {
                 optionsNonNull.outStream.write(os.EOL);
             }
         });
-        var stdbuffer = '';
         (_b = cp.stdout) === null || _b === void 0 ? void 0 : _b.on('data', function (data) {
             _this.emit('stdout', data);
             if (!optionsNonNull.silent) {
                 optionsNonNull.outStream.write(data);
             }
-            _this._processLineBuffer(data, stdbuffer, function (line) {
+            stdLineBuffer = _this._processLineBuffer(data, stdLineBuffer, function (line) {
                 _this.emit('stdline', line);
             });
         });
-        var errbuffer = '';
         (_c = cp.stderr) === null || _c === void 0 ? void 0 : _c.on('data', function (data) {
             state.processStderr = true;
             _this.emit('stderr', data);
@@ -815,7 +1028,7 @@ var ToolRunner = /** @class */ (function (_super) {
                 var s = optionsNonNull.failOnStdErr ? optionsNonNull.errStream : optionsNonNull.outStream;
                 s.write(data);
             }
-            _this._processLineBuffer(data, errbuffer, function (line) {
+            errLineBuffer = _this._processLineBuffer(data, errLineBuffer, function (line) {
                 _this.emit('errline', line);
             });
         });
@@ -825,27 +1038,64 @@ var ToolRunner = /** @class */ (function (_super) {
             state.processClosed = true;
             state.CheckComplete();
         });
+        // Do not write debug logs here. Sometimes stdio not closed yet and you can damage user output commands.
         cp.on('exit', function (code, signal) {
             state.processExitCode = code;
+            state.processExitSignal = signal;
             state.processExited = true;
-            _this._debug("Exit code " + code + " received from tool '" + _this.toolPath + "'");
             state.CheckComplete();
         });
         cp.on('close', function (code, signal) {
-            state.processExitCode = code;
-            state.processExited = true;
+            state.processCloseCode = code;
+            state.processCloseSignal = signal;
             state.processClosed = true;
-            _this._debug("STDIO streams have closed for tool '" + _this.toolPath + "'");
+            state.processExited = true;
             state.CheckComplete();
         });
+        return new Promise(emitDoneEvent);
+    };
+    /**
+     * Exec a tool.
+     * Output will be streamed to the live console.
+     * Returns promise with return code
+     *
+     * @deprecated Use the `execAsync` method that returns a native Javascript promise instead
+     * @param     tool     path to tool to exec
+     * @param     options  optional exec options.  See IExecOptions
+     * @returns   number
+     */
+    ToolRunner.prototype.exec = function (options) {
+        var _this = this;
+        var _a, _b, _c;
+        if (this.pipeOutputToTool) {
+            return this.execWithPiping(this.pipeOutputToTool, options);
+        }
+        var defer = Q.defer();
+        this._debug('exec tool: ' + this.toolPath);
+        this._debug('arguments:');
+        this.args.forEach(function (arg) {
+            _this._debug('   ' + arg);
+        });
+        var optionsNonNull = this._cloneExecOptions(options);
+        if (!optionsNonNull.silent) {
+            optionsNonNull.outStream.write(this._getCommandString(optionsNonNull) + os.EOL);
+        }
+        var state = new ExecState(optionsNonNull, this.toolPath);
+        state.on('debug', function (message) {
+            _this._debug(message);
+        });
+        var stdLineBuffer = '';
+        var errLineBuffer = '';
         state.on('done', function (error, exitCode) {
-            if (stdbuffer.length > 0) {
-                _this.emit('stdline', stdbuffer);
+            if (stdLineBuffer.length > 0) {
+                _this.emit('stdline', stdLineBuffer);
             }
-            if (errbuffer.length > 0) {
-                _this.emit('errline', errbuffer);
+            if (errLineBuffer.length > 0) {
+                _this.emit('errline', errLineBuffer);
+            }
+            if (cp) {
+                cp.removeAllListeners();
             }
-            cp.removeAllListeners();
             if (error) {
                 defer.reject(error);
             }
@@ -853,6 +1103,67 @@ var ToolRunner = /** @class */ (function (_super) {
                 defer.resolve(exitCode);
             }
         });
+        // Edge case when the node itself cant's spawn and emit event
+        var cp;
+        try {
+            cp = child.spawn(this._getSpawnFileName(options), this._getSpawnArgs(optionsNonNull), this._getSpawnOptions(options));
+        }
+        catch (error) {
+            state.processError = error.message;
+            state.processExited = true;
+            state.processClosed = true;
+            state.CheckComplete();
+            return defer.promise;
+        }
+        this.childProcess = cp;
+        // it is possible for the child process to end its last line without a new line.
+        // because stdout is buffered, this causes the last line to not get sent to the parent
+        // stream. Adding this event forces a flush before the child streams are closed.
+        (_a = cp.stdout) === null || _a === void 0 ? void 0 : _a.on('finish', function () {
+            if (!optionsNonNull.silent) {
+                optionsNonNull.outStream.write(os.EOL);
+            }
+        });
+        (_b = cp.stdout) === null || _b === void 0 ? void 0 : _b.on('data', function (data) {
+            _this.emit('stdout', data);
+            if (!optionsNonNull.silent) {
+                optionsNonNull.outStream.write(data);
+            }
+            stdLineBuffer = _this._processLineBuffer(data, stdLineBuffer, function (line) {
+                _this.emit('stdline', line);
+            });
+        });
+        (_c = cp.stderr) === null || _c === void 0 ? void 0 : _c.on('data', function (data) {
+            state.processStderr = true;
+            _this.emit('stderr', data);
+            if (!optionsNonNull.silent) {
+                var s = optionsNonNull.failOnStdErr ? optionsNonNull.errStream : optionsNonNull.outStream;
+                s.write(data);
+            }
+            errLineBuffer = _this._processLineBuffer(data, errLineBuffer, function (line) {
+                _this.emit('errline', line);
+            });
+        });
+        cp.on('error', function (err) {
+            state.processError = err.message;
+            state.processExited = true;
+            state.processClosed = true;
+            state.CheckComplete();
+        });
+        // Do not write debug logs here. Sometimes stdio not closed yet and you can damage user output commands.
+        cp.on('exit', function (code, signal) {
+            state.processExitCode = code;
+            state.processExitSignal = signal;
+            state.processExited = true;
+            state.CheckComplete();
+        });
+        cp.on('close', function (code, signal) {
+            state.processCloseCode = code;
+            state.processCloseSignal = signal;
+            state.processClosed = true;
+            state.processExited = true;
+            state.CheckComplete();
+        });
         return defer.promise;
     };
     /**
@@ -893,9 +1204,11 @@ var ToolRunner = /** @class */ (function (_super) {
      * Used to close child process by sending SIGNINT signal.
      * It allows executed script to have some additional logic on SIGINT, before exiting.
      */
-    ToolRunner.prototype.killChildProcess = function () {
+    ToolRunner.prototype.killChildProcess = function (signal) {
+        if (signal === void 0) { signal = "SIGTERM"; }
         if (this.childProcess) {
-            this.childProcess.kill();
+            this._debug("[killChildProcess] Signal ".concat(signal, " received"));
+            this.childProcess.kill(signal);
         }
     };
     return ToolRunner;
@@ -936,6 +1249,7 @@ var ExecState = /** @class */ (function (_super) {
         // determine whether there is an error
         var error;
         if (this.processExited) {
+            this._debug("Process exited with code ".concat(this.processExitCode, " and signal ").concat(this.processExitSignal, " for tool '").concat(this.toolPath, "'"));
             if (this.processError) {
                 error = new Error(im._loc('LIB_ProcessError', this.toolPath, this.processError));
             }
@@ -946,6 +1260,9 @@ var ExecState = /** @class */ (function (_super) {
                 error = new Error(im._loc('LIB_ProcessStderr', this.toolPath));
             }
         }
+        if (this.processClosed) {
+            this._debug("STDIO streams have closed and received exit code ".concat(this.processCloseCode, " and signal ").concat(this.processCloseSignal, " for tool '").concat(this.toolPath, "'"));
+        }
         // clear the timeout
         if (this.timeout) {
             clearTimeout(this.timeout);