teen_process 1.14.1 → 1.16.0

package/README.md

@@ -1,8 +1,6 @@
 node-teen_process
 =================
 
-[![Greenkeeper badge](https://badges.greenkeeper.io/appium/node-teen_process.svg)](https://greenkeeper.io/)
-
 A grown-up version of Node's child_process. `exec` is really useful, but it
 suffers many limitations. This is an es7 (`async`/`await`) implementation of
 `exec` that uses `spawn` under the hood. It takes care of wrapping commands and
@@ -50,6 +48,9 @@ The `exec` function takes some options, with these defaults:
   stdio: "inherit",
   isBuffer: false,
   shell: undefined,
+  logger: undefined,
+  maxStdoutBufferSize: 100 * 1024 * 1024, // 100 MB
+  maxStderrBufferSize: 100 * 1024 * 1024, // 100 MB
 }
 ```
 
@@ -57,6 +58,9 @@ Most of these are self-explanatory. `ignoreOutput` is useful if you have a very
 chatty process whose output you don't care about and don't want to add it to
 the memory consumed by your program.
 
+Both buffer size limits are needed to avoid memory overflow while collecting
+process output. If the overall size of output chunks for different stream types exceeds the the given one then the oldest chunks will be pulled out in order to keep the memory load within the acceptable ranges.
+
 If you're on Windows, you'll want to pass `shell: true`, because `exec`
 actually uses `spawn` under the hood, and is therefore subject to the issues
 noted about Windows + `spawn` in [the Node
@@ -84,6 +88,10 @@ let {stdout, stderr} = await exec('cat', [filename], {isBuffer: true});
 Buffer.isBuffer(stdout); // true
 ```
 
+The `logger` option allows stdout and stderr to be sent to a particular logger,
+as it it received. This is overridden by the `ignoreOutput` option.
+
+
 ## teen_process.SubProcess
 
 `spawn` is already pretty great but for some uses there's a fair amount of

package/build/lib/exec.js

@@ -16,7 +16,13 @@ var _shellQuote = require("shell-quote");
 
 var _bluebird = _interopRequireDefault(require("bluebird"));
 
-function exec(cmd, args = [], opts = {}) {
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _helpers = require("./helpers");
+
+const MAX_BUFFER_SIZE = 100 * 1024 * 1024;
+
+async function exec(cmd, args = [], opts = {}) {
   const rep = (0, _shellQuote.quote)([cmd, ...args]);
   opts = Object.assign({
     timeout: null,
@@ -25,11 +31,14 @@ function exec(cmd, args = [], opts = {}) {
     cwd: undefined,
     env: process.env,
     ignoreOutput: false,
-    stdio: "inherit",
+    stdio: 'inherit',
     isBuffer: false,
-    shell: undefined
+    shell: undefined,
+    logger: undefined,
+    maxStdoutBufferSize: MAX_BUFFER_SIZE,
+    maxStderrBufferSize: MAX_BUFFER_SIZE
   }, opts);
-  return new _bluebird.default((resolve, reject) => {
+  return await new _bluebird.default((resolve, reject) => {
     let proc = (0, _child_process.spawn)(cmd, args, {
       cwd: opts.cwd,
       env: opts.env,
@@ -39,13 +48,11 @@ function exec(cmd, args = [], opts = {}) {
         stderrArr = [],
         timer = null;
     proc.on('error', err => {
-      let msg = `Command '${rep}' errored out: ${err.stack}`;
-
       if (err.errno === 'ENOENT') {
-        msg = `Command '${cmd}' not found. Is it installed?`;
+        err = (0, _helpers.formatEnoent)(err, cmd, opts.cwd);
       }
 
-      reject(new Error(msg));
+      reject(err);
     });
 
     if (proc.stdin) {
@@ -54,31 +61,48 @@ function exec(cmd, args = [], opts = {}) {
       });
     }
 
-    if (proc.stdout) {
-      proc.stdout.on('error', err => {
-        reject(new Error(`Standard output '${err.syscall}' error: ${err.stack}`));
-      });
-    }
+    const handleStream = (streamType, streamProps) => {
+      if (!proc[streamType]) {
+        return;
+      }
 
-    if (proc.stderr) {
-      proc.stderr.on('error', err => {
-        reject(new Error(`Standard error '${err.syscall}' error: ${err.stack}`));
+      proc[streamType].on('error', err => {
+        reject(new Error(`${_lodash.default.capitalize(streamType)} '${err.syscall}' error: ${err.stack}`));
       });
-    }
 
-    if (!opts.ignoreOutput) {
-      if (proc.stdout) {
-        proc.stdout.on('data', data => {
-          stdoutArr.push(data);
-        });
+      if (opts.ignoreOutput) {
+        proc[streamType].on('data', () => {});
+        return;
       }
 
-      if (proc.stderr) {
-        proc.stderr.on('data', data => {
-          stderrArr.push(data);
-        });
-      }
-    }
+      const {
+        chunks,
+        maxSize
+      } = streamProps;
+      let size = 0;
+      proc[streamType].on('data', chunk => {
+        chunks.push(chunk);
+        size += chunk.length;
+
+        while (chunks.length > 1 && size >= maxSize) {
+          size -= chunks[0].length;
+          chunks.shift();
+        }
+
+        if (opts.logger && _lodash.default.isFunction(opts.logger.debug)) {
+          opts.logger.debug(chunk.toString());
+        }
+      });
+    };
+
+    handleStream('stdout', {
+      maxSize: opts.maxStdoutBufferSize,
+      chunks: stdoutArr
+    });
+    handleStream('stderr', {
+      maxSize: opts.maxStderrBufferSize,
+      chunks: stderrArr
+    });
 
     function getStdio(isBuffer) {
       let stdout, stderr;
@@ -147,4 +171,4 @@ var _default = exec;
 exports.default = _default;require('source-map-support').install();
 
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/exec.js"],"names":["exec","cmd","args","opts","rep","Object","assign","timeout","encoding","killSignal","cwd","undefined","env","process","ignoreOutput","stdio","isBuffer","shell","B","resolve","reject","proc","stdoutArr","stderrArr","timer","on","err","msg","stack","errno","Error","stdin","syscall","stdout","stderr","data","push","getStdio","Buffer","concat","toString","code","clearTimeout","setTimeout","kill"],"mappings":";;;;;;;;;;;;AAEA;;AACA;;AACA;;AAGA,SAASA,IAAT,CAAeC,GAAf,EAAoBC,IAAI,GAAG,EAA3B,EAA+BC,IAAI,GAAG,EAAtC,EAA0C;AAExC,QAAMC,GAAG,GAAG,uBAAM,CAACH,GAAD,EAAM,GAAGC,IAAT,CAAN,CAAZ;AAIAC,EAAAA,IAAI,GAAGE,MAAM,CAACC,MAAP,CAAc;AACnBC,IAAAA,OAAO,EAAE,IADU;AAEnBC,IAAAA,QAAQ,EAAE,MAFS;AAGnBC,IAAAA,UAAU,EAAE,SAHO;AAInBC,IAAAA,GAAG,EAAEC,SAJc;AAKnBC,IAAAA,GAAG,EAAEC,OAAO,CAACD,GALM;AAMnBE,IAAAA,YAAY,EAAE,KANK;AAOnBC,IAAAA,KAAK,EAAE,SAPY;AAQnBC,IAAAA,QAAQ,EAAE,KARS;AASnBC,IAAAA,KAAK,EAAEN;AATY,GAAd,EAUJR,IAVI,CAAP;AAaA,SAAO,IAAIe,iBAAJ,CAAM,CAACC,OAAD,EAAUC,MAAV,KAAqB;AAGhC,QAAIC,IAAI,GAAG,0BAAMpB,GAAN,EAAWC,IAAX,EAAiB;AAACQ,MAAAA,GAAG,EAAEP,IAAI,CAACO,GAAX;AAAgBE,MAAAA,GAAG,EAAET,IAAI,CAACS,GAA1B;AAA+BK,MAAAA,KAAK,EAAEd,IAAI,CAACc;AAA3C,KAAjB,CAAX;AACA,QAAIK,SAAS,GAAG,EAAhB;AAAA,QAAoBC,SAAS,GAAG,EAAhC;AAAA,QAAoCC,KAAK,GAAG,IAA5C;AAGAH,IAAAA,IAAI,CAACI,EAAL,CAAQ,OAAR,EAAkBC,GAAD,IAAS;AACxB,UAAIC,GAAG,GAAI,YAAWvB,GAAI,kBAAiBsB,GAAG,CAACE,KAAM,EAArD;;AACA,UAAIF,GAAG,CAACG,KAAJ,KAAc,QAAlB,EAA4B;AAC1BF,QAAAA,GAAG,GAAI,YAAW1B,GAAI,+BAAtB;AACD;;AACDmB,MAAAA,MAAM,CAAC,IAAIU,KAAJ,CAAUH,GAAV,CAAD,CAAN;AACD,KAND;;AAOA,QAAIN,IAAI,CAACU,KAAT,EAAgB;AACdV,MAAAA,IAAI,CAACU,KAAL,CAAWN,EAAX,CAAc,OAAd,EAAwBC,GAAD,IAAS;AAC9BN,QAAAA,MAAM,CAAC,IAAIU,KAAJ,CAAW,mBAAkBJ,GAAG,CAACM,OAAQ,YAAWN,GAAG,CAACE,KAAM,EAA9D,CAAD,CAAN;AACD,OAFD;AAGD;;AACD,QAAIP,IAAI,CAACY,MAAT,EAAiB;AACfZ,MAAAA,IAAI,CAACY,MAAL,CAAYR,EAAZ,CAAe,OAAf,EAAyBC,GAAD,IAAS;AAC/BN,QAAAA,MAAM,CAAC,IAAIU,KAAJ,CAAW,oBAAmBJ,GAAG,CAACM,OAAQ,YAAWN,GAAG,CAACE,KAAM,EAA/D,CAAD,CAAN;AACD,OAFD;AAGD;;AACD,QAAIP,IAAI,CAACa,MAAT,EAAiB;AACfb,MAAAA,IAAI,CAACa,MAAL,CAAYT,EAAZ,CAAe,OAAf,EAAyBC,GAAD,IAAS;AAC/BN,QAAAA,MAAM,CAAC,IAAIU,KAAJ,CAAW,mBAAkBJ,GAAG,CAACM,OAAQ,YAAWN,GAAG,CAACE,KAAM,EAA9D,CAAD,CAAN;AACD,OAFD;AAGD;;AAGD,QAAI,CAACzB,IAAI,CAACW,YAAV,EAAwB;AACtB,UAAIO,IAAI,CAACY,MAAT,EAAiB;AACfZ,QAAAA,IAAI,CAACY,MAAL,CAAYR,EAAZ,CAAe,MAAf,EAAwBU,IAAD,IAAU;AAC/Bb,UAAAA,SAAS,CAACc,IAAV,CAAeD,IAAf;AACD,SAFD;AAGD;;AACD,UAAId,IAAI,CAACa,MAAT,EAAiB;AACfb,QAAAA,IAAI,CAACa,MAAL,CAAYT,EAAZ,CAAe,MAAf,EAAwBU,IAAD,IAAU;AAC/BZ,UAAAA,SAAS,CAACa,IAAV,CAAeD,IAAf;AACD,SAFD;AAGD;AACF;;AAED,aAASE,QAAT,CAAmBrB,QAAnB,EAA6B;AAC3B,UAAIiB,MAAJ,EAAYC,MAAZ;;AACA,UAAIlB,QAAJ,EAAc;AACZiB,QAAAA,MAAM,GAAGK,MAAM,CAACC,MAAP,CAAcjB,SAAd,CAAT;AACAY,QAAAA,MAAM,GAAGI,MAAM,CAACC,MAAP,CAAchB,SAAd,CAAT;AACD,OAHD,MAGO;AACLU,QAAAA,MAAM,GAAGK,MAAM,CAACC,MAAP,CAAcjB,SAAd,EAAyBkB,QAAzB,CAAkCrC,IAAI,CAACK,QAAvC,CAAT;AACA0B,QAAAA,MAAM,GAAGI,MAAM,CAACC,MAAP,CAAchB,SAAd,EAAyBiB,QAAzB,CAAkCrC,IAAI,CAACK,QAAvC,CAAT;AACD;;AACD,aAAO;AAACyB,QAAAA,MAAD;AAASC,QAAAA;AAAT,OAAP;AACD;;AAKDb,IAAAA,IAAI,CAACI,EAAL,CAAQ,OAAR,EAAkBgB,IAAD,IAAU;AACzB,UAAIjB,KAAJ,EAAW;AACTkB,QAAAA,YAAY,CAAClB,KAAD,CAAZ;AACD;;AACD,UAAI;AAACS,QAAAA,MAAD;AAASC,QAAAA;AAAT,UAAmBG,QAAQ,CAAClC,IAAI,CAACa,QAAN,CAA/B;;AACA,UAAIyB,IAAI,KAAK,CAAb,EAAgB;AACdtB,QAAAA,OAAO,CAAC;AAACc,UAAAA,MAAD;AAASC,UAAAA,MAAT;AAAiBO,UAAAA;AAAjB,SAAD,CAAP;AACD,OAFD,MAEO;AACL,YAAIf,GAAG,GAAG,IAAII,KAAJ,CAAW,YAAW1B,GAAI,sBAAqBqC,IAAK,EAApD,CAAV;AACAf,QAAAA,GAAG,GAAGrB,MAAM,CAACC,MAAP,CAAcoB,GAAd,EAAmB;AAACO,UAAAA,MAAD;AAASC,UAAAA,MAAT;AAAiBO,UAAAA;AAAjB,SAAnB,CAAN;AACArB,QAAAA,MAAM,CAACM,GAAD,CAAN;AACD;AACF,KAZD;;AAiBA,QAAIvB,IAAI,CAACI,OAAT,EAAkB;AAChBiB,MAAAA,KAAK,GAAGmB,UAAU,CAAC,MAAM;AACvB,YAAI;AAACV,UAAAA,MAAD;AAASC,UAAAA;AAAT,YAAmBG,QAAQ,CAAClC,IAAI,CAACa,QAAN,CAA/B;AACA,YAAIU,GAAG,GAAG,IAAII,KAAJ,CAAW,YAAW1B,GAAI,qBAAoBD,IAAI,CAACI,OAAQ,IAA3D,CAAV;AACAmB,QAAAA,GAAG,GAAGrB,MAAM,CAACC,MAAP,CAAcoB,GAAd,EAAmB;AAACO,UAAAA,MAAD;AAASC,UAAAA,MAAT;AAAiBO,UAAAA,IAAI,EAAE;AAAvB,SAAnB,CAAN;AACArB,QAAAA,MAAM,CAACM,GAAD,CAAN;AAGAL,QAAAA,IAAI,CAACuB,IAAL,CAAUzC,IAAI,CAACM,UAAf;AACD,OARiB,EAQfN,IAAI,CAACI,OARU,CAAlB;AASD;AACF,GAvFM,CAAP;AAwFD;;eAGcP,I","sourcesContent":["/* eslint-disable promise/prefer-await-to-callbacks */\n\nimport { spawn } from 'child_process';\nimport { quote } from 'shell-quote';\nimport B from 'bluebird';\n\n\nfunction exec (cmd, args = [], opts = {}) {\n  // get a quoted representation of the command for error strings\n  const rep = quote([cmd, ...args]);\n\n  // extend default options; we're basically re-implementing exec's options\n  // for use here with spawn under the hood\n  opts = Object.assign({\n    timeout: null,\n    encoding: 'utf8',\n    killSignal: 'SIGTERM',\n    cwd: undefined,\n    env: process.env,\n    ignoreOutput: false,\n    stdio: \"inherit\",\n    isBuffer: false,\n    shell: undefined,\n  }, opts);\n\n  // this is an async function, so return a promise\n  return new B((resolve, reject) => {\n    // spawn the child process with options; we don't currently expose any of\n    // the other 'spawn' options through the API\n    let proc = spawn(cmd, args, {cwd: opts.cwd, env: opts.env, shell: opts.shell});\n    let stdoutArr = [], stderrArr = [], timer = null;\n\n    // if the process errors out, reject the promise\n    proc.on('error', (err) => {\n      let msg = `Command '${rep}' errored out: ${err.stack}`;\n      if (err.errno === 'ENOENT') {\n        msg = `Command '${cmd}' not found. Is it installed?`;\n      }\n      reject(new Error(msg));\n    });\n    if (proc.stdin) {\n      proc.stdin.on('error', (err) => {\n        reject(new Error(`Standard input '${err.syscall}' error: ${err.stack}`));\n      });\n    }\n    if (proc.stdout) {\n      proc.stdout.on('error', (err) => {\n        reject(new Error(`Standard output '${err.syscall}' error: ${err.stack}`));\n      });\n    }\n    if (proc.stderr) {\n      proc.stderr.on('error', (err) => {\n        reject(new Error(`Standard error '${err.syscall}' error: ${err.stack}`));\n      });\n    }\n\n    // keep track of stdout/stderr if we haven't said not to\n    if (!opts.ignoreOutput) {\n      if (proc.stdout) {\n        proc.stdout.on('data', (data) => {\n          stdoutArr.push(data);\n        });\n      }\n      if (proc.stderr) {\n        proc.stderr.on('data', (data) => {\n          stderrArr.push(data);\n        });\n      }\n    }\n\n    function getStdio (isBuffer) {\n      let stdout, stderr;\n      if (isBuffer) {\n        stdout = Buffer.concat(stdoutArr);\n        stderr = Buffer.concat(stderrArr);\n      } else {\n        stdout = Buffer.concat(stdoutArr).toString(opts.encoding);\n        stderr = Buffer.concat(stderrArr).toString(opts.encoding);\n      }\n      return {stdout, stderr};\n    }\n\n    // if the process ends, either resolve or reject the promise based on the\n    // exit code of the process. either way, attach stdout, stderr, and code.\n    // Also clean up the timer if it exists\n    proc.on('close', (code) => {\n      if (timer) {\n        clearTimeout(timer);\n      }\n      let {stdout, stderr} = getStdio(opts.isBuffer);\n      if (code === 0) {\n        resolve({stdout, stderr, code});\n      } else {\n        let err = new Error(`Command '${rep}' exited with code ${code}`);\n        err = Object.assign(err, {stdout, stderr, code});\n        reject(err);\n      }\n    });\n\n    // if we set a timeout on the child process, cut into the execution and\n    // reject if the timeout is reached. Attach the stdout/stderr we currently\n    // have in case it's helpful in debugging\n    if (opts.timeout) {\n      timer = setTimeout(() => {\n        let {stdout, stderr} = getStdio(opts.isBuffer);\n        let err = new Error(`Command '${rep}' timed out after ${opts.timeout}ms`);\n        err = Object.assign(err, {stdout, stderr, code: null});\n        reject(err);\n        // reject and THEN kill to avoid race conditions with the handlers\n        // above\n        proc.kill(opts.killSignal);\n      }, opts.timeout);\n    }\n  });\n}\n\nexport { exec };\nexport default exec;\n"],"file":"lib/exec.js","sourceRoot":"../.."}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/exec.js"],"names":["MAX_BUFFER_SIZE","exec","cmd","args","opts","rep","Object","assign","timeout","encoding","killSignal","cwd","undefined","env","process","ignoreOutput","stdio","isBuffer","shell","logger","maxStdoutBufferSize","maxStderrBufferSize","B","resolve","reject","proc","stdoutArr","stderrArr","timer","on","err","errno","stdin","Error","syscall","stack","handleStream","streamType","streamProps","_","capitalize","chunks","maxSize","size","chunk","push","length","shift","isFunction","debug","toString","getStdio","stdout","stderr","Buffer","concat","code","clearTimeout","setTimeout","kill"],"mappings":"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","sourcesContent":["/* eslint-disable promise/prefer-await-to-callbacks */\n\nimport { spawn } from 'child_process';\nimport { quote } from 'shell-quote';\nimport B from 'bluebird';\nimport _ from 'lodash';\nimport { formatEnoent } from './helpers';\n\nconst MAX_BUFFER_SIZE = 100 * 1024 * 1024;\n\nasync function exec (cmd, args = [], opts = {}) {\n  // get a quoted representation of the command for error strings\n  const rep = quote([cmd, ...args]);\n\n  // extend default options; we're basically re-implementing exec's options\n  // for use here with spawn under the hood\n  opts = Object.assign({\n    timeout: null,\n    encoding: 'utf8',\n    killSignal: 'SIGTERM',\n    cwd: undefined,\n    env: process.env,\n    ignoreOutput: false,\n    stdio: 'inherit',\n    isBuffer: false,\n    shell: undefined,\n    logger: undefined,\n    maxStdoutBufferSize: MAX_BUFFER_SIZE,\n    maxStderrBufferSize: MAX_BUFFER_SIZE,\n  }, opts);\n\n  // this is an async function, so return a promise\n  return await new B((resolve, reject) => {\n    // spawn the child process with options; we don't currently expose any of\n    // the other 'spawn' options through the API\n    let proc = spawn(cmd, args, {cwd: opts.cwd, env: opts.env, shell: opts.shell});\n    let stdoutArr = [], stderrArr = [], timer = null;\n\n    // if the process errors out, reject the promise\n    proc.on('error', (err) => {\n      if (err.errno === 'ENOENT') {\n        err = formatEnoent(err, cmd, opts.cwd);\n      }\n      reject(err);\n    });\n    if (proc.stdin) {\n      proc.stdin.on('error', (err) => {\n        reject(new Error(`Standard input '${err.syscall}' error: ${err.stack}`));\n      });\n    }\n    const handleStream = (streamType, streamProps) => {\n      if (!proc[streamType]) {\n        return;\n      }\n\n      proc[streamType].on('error', (err) => {\n        reject(new Error(`${_.capitalize(streamType)} '${err.syscall}' error: ${err.stack}`));\n      });\n\n      if (opts.ignoreOutput) {\n        // https://github.com/nodejs/node/issues/4236\n        proc[streamType].on('data', () => {});\n        return;\n      }\n\n      // keep track of the stream if we don't want to ignore it\n      const {chunks, maxSize} = streamProps;\n      let size = 0;\n      proc[streamType].on('data', (chunk) => {\n        chunks.push(chunk);\n        size += chunk.length;\n        while (chunks.length > 1 && size >= maxSize) {\n          size -= chunks[0].length;\n          chunks.shift();\n        }\n        if (opts.logger && _.isFunction(opts.logger.debug)) {\n          opts.logger.debug(chunk.toString());\n        }\n      });\n    };\n    handleStream('stdout', {\n      maxSize: opts.maxStdoutBufferSize,\n      chunks: stdoutArr,\n    });\n    handleStream('stderr', {\n      maxSize: opts.maxStderrBufferSize,\n      chunks: stderrArr,\n    });\n\n    function getStdio (isBuffer) {\n      let stdout, stderr;\n      if (isBuffer) {\n        stdout = Buffer.concat(stdoutArr);\n        stderr = Buffer.concat(stderrArr);\n      } else {\n        stdout = Buffer.concat(stdoutArr).toString(opts.encoding);\n        stderr = Buffer.concat(stderrArr).toString(opts.encoding);\n      }\n      return {stdout, stderr};\n    }\n\n    // if the process ends, either resolve or reject the promise based on the\n    // exit code of the process. either way, attach stdout, stderr, and code.\n    // Also clean up the timer if it exists\n    proc.on('close', (code) => {\n      if (timer) {\n        clearTimeout(timer);\n      }\n      let {stdout, stderr} = getStdio(opts.isBuffer);\n      if (code === 0) {\n        resolve({stdout, stderr, code});\n      } else {\n        let err = new Error(`Command '${rep}' exited with code ${code}`);\n        err = Object.assign(err, {stdout, stderr, code});\n        reject(err);\n      }\n    });\n\n    // if we set a timeout on the child process, cut into the execution and\n    // reject if the timeout is reached. Attach the stdout/stderr we currently\n    // have in case it's helpful in debugging\n    if (opts.timeout) {\n      timer = setTimeout(() => {\n        let {stdout, stderr} = getStdio(opts.isBuffer);\n        let err = new Error(`Command '${rep}' timed out after ${opts.timeout}ms`);\n        err = Object.assign(err, {stdout, stderr, code: null});\n        reject(err);\n        // reject and THEN kill to avoid race conditions with the handlers\n        // above\n        proc.kill(opts.killSignal);\n      }, opts.timeout);\n    }\n  });\n}\n\nexport { exec };\nexport default exec;\n"],"file":"lib/exec.js","sourceRoot":"../.."}

package/build/lib/helpers.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatEnoent = formatEnoent;
+
+require("source-map-support/register");
+
+var _which = _interopRequireDefault(require("which"));
+
+var _fs = _interopRequireDefault(require("fs"));
+
+function formatEnoent(error, cmd, cwd = null) {
+  try {
+    _which.default.sync(cmd);
+
+    if (cwd) {
+      try {
+        _fs.default.accessSync(cwd, _fs.default.R_OK);
+      } catch (ign) {
+        error.message = `The current working directory '${cwd}' for '${cmd}' command ` + `either does not exist or is not accessible`;
+      }
+    }
+  } catch (ign) {
+    error.message = `Command '${cmd}' not found. Is it installed?`;
+  }
+
+  return error;
+}require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/build/lib/subprocess.js

@@ -13,17 +13,22 @@ var _child_process = require("child_process");
 
 var _events = _interopRequireDefault(require("events"));
 
-var _through = _interopRequireDefault(require("through"));
-
 var _bluebird = _interopRequireDefault(require("bluebird"));
 
 var _shellQuote = require("shell-quote");
 
 var _lodash = _interopRequireDefault(require("lodash"));
 
+var _helpers = require("./helpers");
+
 const {
   EventEmitter
 } = _events.default;
+const MAX_LINE_PORTION_LENGTH = 0xFFFF;
+
+function cutSuffix(str, suffixLength) {
+  return str.length > suffixLength ? ` ${str.substr(str.length - suffixLength)}`.substr(1) : str;
+}
 
 class SubProcess extends EventEmitter {
   constructor(cmd, args = [], opts = {}) {
@@ -97,9 +102,14 @@ class SubProcess extends EventEmitter {
         stderr: ''
       };
 
-      const handleOutput = data => {
+      const handleOutput = streams => {
+        const {
+          stdout,
+          stderr
+        } = streams;
+
         try {
-          if (startDetector && startDetector(data.stdout, data.stderr)) {
+          if (startDetector && startDetector(stdout, stderr)) {
             startDetector = null;
             resolve();
           }
@@ -107,20 +117,26 @@ class SubProcess extends EventEmitter {
           reject(e);
         }
 
-        this.emit('output', data.stdout, data.stderr);
+        this.emit('output', stdout, stderr);
 
-        for (const stream of ['stdout', 'stderr']) {
-          if (!data[stream]) continue;
-          let lines = data[stream].split("\n");
+        for (const [streamName, streamData] of _lodash.default.toPairs(streams)) {
+          if (!streamData) continue;
+          const lines = streamData.split('\n').map(x => ` ${x}`.substr(1));
 
           if (lines.length > 1) {
-            let retLines = lines.slice(0, -1);
-            retLines[0] = this.lastLinePortion[stream] + retLines[0];
-            this.lastLinePortion[stream] = lines[lines.length - 1];
-            this.emit(`lines-${stream}`, retLines);
-            this.emitLines(stream, retLines);
+            lines[0] = this.lastLinePortion[streamName] + lines[0];
+            this.lastLinePortion[streamName] = cutSuffix(_lodash.default.last(lines), MAX_LINE_PORTION_LENGTH);
+            const resultLines = lines.slice(0, -1);
+            this.emit(`lines-${streamName}`, resultLines);
+            this.emitLines(streamName, resultLines);
           } else {
-            this.lastLinePortion[stream] += lines[0];
+            const currentPortion = cutSuffix(lines[0], MAX_LINE_PORTION_LENGTH);
+
+            if (this.lastLinePortion[streamName].length + currentPortion.length > MAX_LINE_PORTION_LENGTH) {
+              this.lastLinePortion[streamName] = currentPortion;
+            } else {
+              this.lastLinePortion[streamName] += currentPortion;
+            }
           }
         }
       };
@@ -130,27 +146,25 @@ class SubProcess extends EventEmitter {
         this.proc.kill('SIGINT');
 
         if (err.errno === 'ENOENT') {
-          err = new Error(`Command '${this.cmd}' not found. Is it installed?`);
+          var _this$opts;
+
+          err = (0, _helpers.formatEnoent)(err, this.cmd, (_this$opts = this.opts) === null || _this$opts === void 0 ? void 0 : _this$opts.cwd);
         }
 
         reject(err);
       });
 
       if (this.proc.stdout) {
-        this.proc.stdout.pipe((0, _through.default)(stdout => {
-          handleOutput({
-            stdout,
-            stderr: ''
-          });
+        this.proc.stdout.on('data', chunk => handleOutput({
+          stdout: chunk.toString(),
+          stderr: ''
         }));
       }
 
       if (this.proc.stderr) {
-        this.proc.stderr.pipe((0, _through.default)(stderr => {
-          handleOutput({
-            stdout: '',
-            stderr
-          });
+        this.proc.stderr.on('data', chunk => handleOutput({
+          stdout: '',
+          stderr: chunk.toString()
         }));
       }
 
@@ -250,4 +264,4 @@ var _default = SubProcess;
 exports.default = _default;require('source-map-support').install();
 
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/subprocess.js"],"names":["EventEmitter","events","SubProcess","constructor","cmd","args","opts","Error","_","isString","isArray","proc","expectingExit","rep","isRunning","emitLines","stream","lines","line","emit","toUpperCase","start","startDetector","timeoutMs","detach","startDelay","genericStartDetector","stdout","stderr","isNumber","isBoolean","detached","B","resolve","reject","setEncoding","encoding","lastLinePortion","handleOutput","data","e","split","length","retLines","slice","on","err","removeAllListeners","kill","errno","pipe","code","signal","handleLastLines","event","setTimeout","finally","unref","lastLines","stop","timeout","join","allowedExitCodes","indexOf","detachProcess","pid"],"mappings":"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","sourcesContent":["/* eslint-disable promise/prefer-await-to-callbacks */\n\nimport { spawn } from 'child_process';\nimport events from 'events';\nimport through from 'through';\nconst { EventEmitter } = events;\nimport B from 'bluebird';\nimport { quote } from 'shell-quote';\nimport _ from 'lodash';\n\n\nclass SubProcess extends EventEmitter {\n  constructor (cmd, args = [], opts = {}) {\n    super();\n    if (!cmd) throw new Error('Command is required'); // eslint-disable-line curly\n    if (!_.isString(cmd)) throw new Error('Command must be a string'); // eslint-disable-line curly\n    if (!_.isArray(args)) throw new Error('Args must be an array'); // eslint-disable-line curly\n\n    this.cmd = cmd;\n    this.args = args;\n    this.proc = null;\n    this.opts = opts;\n    this.expectingExit = false;\n\n    // get a quoted representation of the command for error strings\n    this.rep = quote([cmd, ...args]);\n  }\n\n  get isRunning () {\n    // presence of `proc` means we have connected and started\n    return !!this.proc;\n  }\n\n  emitLines (stream, lines) {\n    for (let line of lines) {\n      this.emit('stream-line', `[${stream.toUpperCase()}] ${line}`);\n    }\n  }\n\n  // spawn the subprocess and return control whenever we deem that it has fully\n  // \"started\"\n  async start (startDetector = null, timeoutMs = null, detach = false) {\n    let startDelay = 10;\n\n    const genericStartDetector = function genericStartDetector (stdout, stderr) {\n      return stdout || stderr;\n    };\n\n    // the default start detector simply returns true when we get any output\n    if (startDetector === null) {\n      startDetector = genericStartDetector;\n    }\n\n    // if the user passes a number, then we simply delay a certain amount of\n    // time before returning control, rather than waiting for a condition\n    if (_.isNumber(startDetector)) {\n      startDelay = startDetector;\n      startDetector = null;\n    }\n\n    // if the user passes in a boolean as one of the arguments, use it for `detach`\n    if (_.isBoolean(startDetector) && startDetector) {\n      if (!this.opts.detached) {\n        throw new Error(`Unable to detach process that is not started with 'detached' option`);\n      }\n      detach = true;\n      startDetector = genericStartDetector;\n    } else if (_.isBoolean(timeoutMs) && timeoutMs) {\n      if (!this.opts.detached) {\n        throw new Error(`Unable to detach process that is not started with 'detached' option`);\n      }\n      detach = true;\n      timeoutMs = null;\n    }\n\n    // return a promise so we can wrap the async behavior\n    return await new B((resolve, reject) => {\n      // actually spawn the subproc\n      this.proc = spawn(this.cmd, this.args, this.opts);\n\n      if (this.proc.stdout) {\n        this.proc.stdout.setEncoding(this.opts.encoding || 'utf8');\n      }\n      if (this.proc.stderr) {\n        this.proc.stderr.setEncoding(this.opts.encoding || 'utf8');\n      }\n      this.lastLinePortion = {stdout: '', stderr: ''};\n\n      // this function handles output that we collect from the subproc\n      const handleOutput = (data) => {\n        // if we have a startDetector, run it on the output so we can resolve/\n        // reject and move on from start\n        try {\n          if (startDetector && startDetector(data.stdout, data.stderr)) {\n            startDetector = null;\n            resolve();\n          }\n        } catch (e) {\n          reject(e);\n        }\n\n        // emit the actual output for whomever's listening\n        this.emit('output', data.stdout, data.stderr);\n\n        // we also want to emit lines, but it's more complex since output\n        // comes in chunks and a line could come in two different chunks, so\n        // we have logic to handle that case (using this.lastLinePortion to\n        // remember a line that started but did not finish in the last chunk)\n        for (const stream of ['stdout', 'stderr']) {\n          if (!data[stream]) continue; // eslint-disable-line curly\n          let lines = data[stream].split(\"\\n\");\n          if (lines.length > 1) {\n            let retLines = lines.slice(0, -1);\n            retLines[0] = this.lastLinePortion[stream] + retLines[0];\n            this.lastLinePortion[stream] = lines[lines.length - 1];\n            this.emit(`lines-${stream}`, retLines);\n            this.emitLines(stream, retLines);\n          } else {\n            this.lastLinePortion[stream] += lines[0];\n          }\n        }\n      };\n\n      // if we get an error spawning the proc, reject and clean up the proc\n      this.proc.on('error', err => {\n        this.proc.removeAllListeners('exit');\n        this.proc.kill('SIGINT');\n\n        if (err.errno === 'ENOENT') {\n          err = new Error(`Command '${this.cmd}' not found. Is it installed?`);\n        }\n        reject(err);\n      });\n\n      if (this.proc.stdout) {\n        this.proc.stdout.pipe(through(stdout => {\n          handleOutput({stdout, stderr: ''});\n        }));\n      }\n\n      if (this.proc.stderr) {\n        this.proc.stderr.pipe(through(stderr => {\n          handleOutput({stdout: '', stderr});\n        }));\n      }\n\n      // when the proc exits, we might still have a buffer of lines we were\n      // waiting on more chunks to complete. Go ahead and emit those, then\n      // re-emit the exit so a listener can handle the possibly-unexpected exit\n      this.proc.on('exit', (code, signal) => {\n        this.handleLastLines();\n\n        this.emit('exit', code, signal);\n\n        // in addition to the bare exit event, also emit one of three other\n        // events that contain more helpful information:\n        // 'stop': we stopped this\n        // 'die': the process ended out of our control with a non-zero exit\n        // 'end': the process ended out of our control with a zero exit\n        let event = this.expectingExit ? 'stop' : 'die';\n        if (!this.expectingExit && code === 0) {\n          event = 'end';\n        }\n        this.emit(event, code, signal);\n\n        // finally clean up the proc and make sure to reset our exit\n        // expectations\n        this.proc = null;\n        this.expectingExit = false;\n      });\n\n      // if the user hasn't given us a startDetector, instead just resolve\n      // when startDelay ms have passed\n      if (!startDetector) {\n        setTimeout(() => { resolve(); }, startDelay);\n      }\n\n      // if the user has given us a timeout, start the clock for rejecting\n      // the promise if we take too long to start\n      if (_.isNumber(timeoutMs)) {\n        setTimeout(() => {\n          reject(new Error(`The process did not start within ${timeoutMs}ms ` +\n            `(cmd: '${this.rep}')`));\n        }, timeoutMs);\n      }\n    }).finally(() => {\n      if (detach && this.proc) {\n        this.proc.unref();\n      }\n    });\n  }\n\n  handleLastLines () {\n    for (let stream of ['stdout', 'stderr']) {\n      if (this.lastLinePortion[stream]) {\n        const lastLines = [this.lastLinePortion[stream]];\n        this.emit(`lines-${stream}`, lastLines);\n        this.emitLines(stream, lastLines);\n        this.lastLinePortion[stream] = '';\n      }\n    }\n  }\n\n  async stop (signal = 'SIGTERM', timeout = 10000) {\n    if (!this.isRunning) {\n      throw new Error(`Can't stop process; it's not currently running (cmd: '${this.rep}')`);\n    }\n    // make sure to emit any data in our lines buffer whenever we're done with\n    // the proc\n    this.handleLastLines();\n    return await new B((resolve, reject) => {\n      this.proc.on('close', resolve);\n      this.expectingExit = true;\n      this.proc.kill(signal);\n      setTimeout(() => {\n        reject(new Error(`Process didn't end after ${timeout}ms (cmd: '${this.rep}')`));\n      }, timeout);\n    });\n  }\n\n  async join (allowedExitCodes = [0]) {\n    if (!this.isRunning) {\n      throw new Error(`Cannot join process; it is not currently running (cmd: '${this.rep}')`);\n    }\n\n    return await new B((resolve, reject) => {\n      this.proc.on('exit', (code) => {\n        if (allowedExitCodes.indexOf(code) === -1) {\n          reject(new Error(`Process ended with exitcode ${code} (cmd: '${this.rep}')`));\n        } else {\n          resolve(code);\n        }\n      });\n    });\n  }\n\n  /*\n   * This will only work if the process is created with the `detached` option\n   */\n  detachProcess () {\n    if (!this.opts.detached) {\n      // this means that there is a misconfiguration in the calling code\n      throw new Error(`Unable to detach process that is not started with 'detached' option`);\n    }\n    if (this.proc) {\n      this.proc.unref();\n    }\n  }\n\n  get pid () {\n    return this.proc ? this.proc.pid : null;\n  }\n}\n\nexport { SubProcess };\nexport default SubProcess;\n"],"file":"lib/subprocess.js","sourceRoot":"../.."}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/subprocess.js"],"names":["EventEmitter","events","MAX_LINE_PORTION_LENGTH","cutSuffix","str","suffixLength","length","substr","SubProcess","constructor","cmd","args","opts","Error","_","isString","isArray","proc","expectingExit","rep","isRunning","emitLines","stream","lines","line","emit","toUpperCase","start","startDetector","timeoutMs","detach","startDelay","genericStartDetector","stdout","stderr","isNumber","isBoolean","detached","B","resolve","reject","setEncoding","encoding","lastLinePortion","handleOutput","streams","e","streamName","streamData","toPairs","split","map","x","last","resultLines","slice","currentPortion","on","err","removeAllListeners","kill","errno","cwd","chunk","toString","code","signal","handleLastLines","event","setTimeout","finally","unref","lastLines","stop","timeout","join","allowedExitCodes","indexOf","detachProcess","pid"],"mappings":"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","sourcesContent":["/* eslint-disable promise/prefer-await-to-callbacks */\n\nimport { spawn } from 'child_process';\nimport events from 'events';\nconst { EventEmitter } = events;\nimport B from 'bluebird';\nimport { quote } from 'shell-quote';\nimport _ from 'lodash';\nimport { formatEnoent } from './helpers';\n\n\n// This is needed to avoid memory leaks\n// when the process output is too long and contains\n// no line breaks\nconst MAX_LINE_PORTION_LENGTH = 0xFFFF;\n\nfunction cutSuffix (str, suffixLength) {\n  return str.length > suffixLength\n    // https://bugs.chromium.org/p/v8/issues/detail?id=2869\n    ? ` ${str.substr(str.length - suffixLength)}`.substr(1)\n    : str;\n}\n\n\nclass SubProcess extends EventEmitter {\n  constructor (cmd, args = [], opts = {}) {\n    super();\n    if (!cmd) throw new Error('Command is required'); // eslint-disable-line curly\n    if (!_.isString(cmd)) throw new Error('Command must be a string'); // eslint-disable-line curly\n    if (!_.isArray(args)) throw new Error('Args must be an array'); // eslint-disable-line curly\n\n    this.cmd = cmd;\n    this.args = args;\n    this.proc = null;\n    this.opts = opts;\n    this.expectingExit = false;\n\n    // get a quoted representation of the command for error strings\n    this.rep = quote([cmd, ...args]);\n  }\n\n  get isRunning () {\n    // presence of `proc` means we have connected and started\n    return !!this.proc;\n  }\n\n  emitLines (stream, lines) {\n    for (let line of lines) {\n      this.emit('stream-line', `[${stream.toUpperCase()}] ${line}`);\n    }\n  }\n\n  // spawn the subprocess and return control whenever we deem that it has fully\n  // \"started\"\n  async start (startDetector = null, timeoutMs = null, detach = false) {\n    let startDelay = 10;\n\n    const genericStartDetector = function genericStartDetector (stdout, stderr) {\n      return stdout || stderr;\n    };\n\n    // the default start detector simply returns true when we get any output\n    if (startDetector === null) {\n      startDetector = genericStartDetector;\n    }\n\n    // if the user passes a number, then we simply delay a certain amount of\n    // time before returning control, rather than waiting for a condition\n    if (_.isNumber(startDetector)) {\n      startDelay = startDetector;\n      startDetector = null;\n    }\n\n    // if the user passes in a boolean as one of the arguments, use it for `detach`\n    if (_.isBoolean(startDetector) && startDetector) {\n      if (!this.opts.detached) {\n        throw new Error(`Unable to detach process that is not started with 'detached' option`);\n      }\n      detach = true;\n      startDetector = genericStartDetector;\n    } else if (_.isBoolean(timeoutMs) && timeoutMs) {\n      if (!this.opts.detached) {\n        throw new Error(`Unable to detach process that is not started with 'detached' option`);\n      }\n      detach = true;\n      timeoutMs = null;\n    }\n\n    // return a promise so we can wrap the async behavior\n    return await new B((resolve, reject) => {\n      // actually spawn the subproc\n      this.proc = spawn(this.cmd, this.args, this.opts);\n\n      if (this.proc.stdout) {\n        this.proc.stdout.setEncoding(this.opts.encoding || 'utf8');\n      }\n      if (this.proc.stderr) {\n        this.proc.stderr.setEncoding(this.opts.encoding || 'utf8');\n      }\n      this.lastLinePortion = {stdout: '', stderr: ''};\n\n      // this function handles output that we collect from the subproc\n      const handleOutput = (streams) => {\n        const {stdout, stderr} = streams;\n        // if we have a startDetector, run it on the output so we can resolve/\n        // reject and move on from start\n        try {\n          if (startDetector && startDetector(stdout, stderr)) {\n            startDetector = null;\n            resolve();\n          }\n        } catch (e) {\n          reject(e);\n        }\n\n        // emit the actual output for whomever's listening\n        this.emit('output', stdout, stderr);\n\n        // we also want to emit lines, but it's more complex since output\n        // comes in chunks and a line could come in two different chunks, so\n        // we have logic to handle that case (using this.lastLinePortion to\n        // remember a line that started but did not finish in the last chunk)\n        for (const [streamName, streamData] of _.toPairs(streams)) {\n          if (!streamData) continue; // eslint-disable-line curly\n          const lines = streamData.split('\\n')\n            // https://bugs.chromium.org/p/v8/issues/detail?id=2869\n            .map((x) => ` ${x}`.substr(1));\n          if (lines.length > 1) {\n            lines[0] = this.lastLinePortion[streamName] + lines[0];\n            this.lastLinePortion[streamName] = cutSuffix(_.last(lines), MAX_LINE_PORTION_LENGTH);\n            const resultLines = lines.slice(0, -1);\n            this.emit(`lines-${streamName}`, resultLines);\n            this.emitLines(streamName, resultLines);\n          } else {\n            const currentPortion = cutSuffix(lines[0], MAX_LINE_PORTION_LENGTH);\n            if (this.lastLinePortion[streamName].length + currentPortion.length > MAX_LINE_PORTION_LENGTH) {\n              this.lastLinePortion[streamName] = currentPortion;\n            } else {\n              this.lastLinePortion[streamName] += currentPortion;\n            }\n          }\n        }\n      };\n\n      // if we get an error spawning the proc, reject and clean up the proc\n      this.proc.on('error', (err) => {\n        this.proc.removeAllListeners('exit');\n        this.proc.kill('SIGINT');\n\n        if (err.errno === 'ENOENT') {\n          err = formatEnoent(err, this.cmd, this.opts?.cwd);\n        }\n        reject(err);\n      });\n\n      if (this.proc.stdout) {\n        this.proc.stdout.on('data', (chunk) => handleOutput({stdout: chunk.toString(), stderr: ''}));\n      }\n\n      if (this.proc.stderr) {\n        this.proc.stderr.on('data', (chunk) => handleOutput({stdout: '', stderr: chunk.toString()}));\n      }\n\n      // when the proc exits, we might still have a buffer of lines we were\n      // waiting on more chunks to complete. Go ahead and emit those, then\n      // re-emit the exit so a listener can handle the possibly-unexpected exit\n      this.proc.on('exit', (code, signal) => {\n        this.handleLastLines();\n\n        this.emit('exit', code, signal);\n\n        // in addition to the bare exit event, also emit one of three other\n        // events that contain more helpful information:\n        // 'stop': we stopped this\n        // 'die': the process ended out of our control with a non-zero exit\n        // 'end': the process ended out of our control with a zero exit\n        let event = this.expectingExit ? 'stop' : 'die';\n        if (!this.expectingExit && code === 0) {\n          event = 'end';\n        }\n        this.emit(event, code, signal);\n\n        // finally clean up the proc and make sure to reset our exit\n        // expectations\n        this.proc = null;\n        this.expectingExit = false;\n      });\n\n      // if the user hasn't given us a startDetector, instead just resolve\n      // when startDelay ms have passed\n      if (!startDetector) {\n        setTimeout(() => { resolve(); }, startDelay);\n      }\n\n      // if the user has given us a timeout, start the clock for rejecting\n      // the promise if we take too long to start\n      if (_.isNumber(timeoutMs)) {\n        setTimeout(() => {\n          reject(new Error(`The process did not start within ${timeoutMs}ms ` +\n            `(cmd: '${this.rep}')`));\n        }, timeoutMs);\n      }\n    }).finally(() => {\n      if (detach && this.proc) {\n        this.proc.unref();\n      }\n    });\n  }\n\n  handleLastLines () {\n    for (let stream of ['stdout', 'stderr']) {\n      if (this.lastLinePortion[stream]) {\n        const lastLines = [this.lastLinePortion[stream]];\n        this.emit(`lines-${stream}`, lastLines);\n        this.emitLines(stream, lastLines);\n        this.lastLinePortion[stream] = '';\n      }\n    }\n  }\n\n  async stop (signal = 'SIGTERM', timeout = 10000) {\n    if (!this.isRunning) {\n      throw new Error(`Can't stop process; it's not currently running (cmd: '${this.rep}')`);\n    }\n    // make sure to emit any data in our lines buffer whenever we're done with\n    // the proc\n    this.handleLastLines();\n    return await new B((resolve, reject) => {\n      this.proc.on('close', resolve);\n      this.expectingExit = true;\n      this.proc.kill(signal);\n      setTimeout(() => {\n        reject(new Error(`Process didn't end after ${timeout}ms (cmd: '${this.rep}')`));\n      }, timeout);\n    });\n  }\n\n  async join (allowedExitCodes = [0]) {\n    if (!this.isRunning) {\n      throw new Error(`Cannot join process; it is not currently running (cmd: '${this.rep}')`);\n    }\n\n    return await new B((resolve, reject) => {\n      this.proc.on('exit', (code) => {\n        if (allowedExitCodes.indexOf(code) === -1) {\n          reject(new Error(`Process ended with exitcode ${code} (cmd: '${this.rep}')`));\n        } else {\n          resolve(code);\n        }\n      });\n    });\n  }\n\n  /*\n   * This will only work if the process is created with the `detached` option\n   */\n  detachProcess () {\n    if (!this.opts.detached) {\n      // this means that there is a misconfiguration in the calling code\n      throw new Error(`Unable to detach process that is not started with 'detached' option`);\n    }\n    if (this.proc) {\n      this.proc.unref();\n    }\n  }\n\n  get pid () {\n    return this.proc ? this.proc.pid : null;\n  }\n}\n\nexport { SubProcess };\nexport default SubProcess;\n"],"file":"lib/subprocess.js","sourceRoot":"../.."}

package/lib/exec.js

@@ -3,9 +3,12 @@
 import { spawn } from 'child_process';
 import { quote } from 'shell-quote';
 import B from 'bluebird';
+import _ from 'lodash';
+import { formatEnoent } from './helpers';
 
+const MAX_BUFFER_SIZE = 100 * 1024 * 1024;
 
-function exec (cmd, args = [], opts = {}) {
+async function exec (cmd, args = [], opts = {}) {
   // get a quoted representation of the command for error strings
   const rep = quote([cmd, ...args]);
 
@@ -18,13 +21,16 @@ function exec (cmd, args = [], opts = {}) {
     cwd: undefined,
     env: process.env,
     ignoreOutput: false,
-    stdio: "inherit",
+    stdio: 'inherit',
     isBuffer: false,
     shell: undefined,
+    logger: undefined,
+    maxStdoutBufferSize: MAX_BUFFER_SIZE,
+    maxStderrBufferSize: MAX_BUFFER_SIZE,
   }, opts);
 
   // this is an async function, so return a promise
-  return new B((resolve, reject) => {
+  return await new B((resolve, reject) => {
     // spawn the child process with options; we don't currently expose any of
     // the other 'spawn' options through the API
     let proc = spawn(cmd, args, {cwd: opts.cwd, env: opts.env, shell: opts.shell});
@@ -32,41 +38,54 @@ function exec (cmd, args = [], opts = {}) {
 
     // if the process errors out, reject the promise
     proc.on('error', (err) => {
-      let msg = `Command '${rep}' errored out: ${err.stack}`;
       if (err.errno === 'ENOENT') {
-        msg = `Command '${cmd}' not found. Is it installed?`;
+        err = formatEnoent(err, cmd, opts.cwd);
       }
-      reject(new Error(msg));
+      reject(err);
     });
     if (proc.stdin) {
       proc.stdin.on('error', (err) => {
         reject(new Error(`Standard input '${err.syscall}' error: ${err.stack}`));
       });
     }
-    if (proc.stdout) {
-      proc.stdout.on('error', (err) => {
-        reject(new Error(`Standard output '${err.syscall}' error: ${err.stack}`));
-      });
-    }
-    if (proc.stderr) {
-      proc.stderr.on('error', (err) => {
-        reject(new Error(`Standard error '${err.syscall}' error: ${err.stack}`));
+    const handleStream = (streamType, streamProps) => {
+      if (!proc[streamType]) {
+        return;
+      }
+
+      proc[streamType].on('error', (err) => {
+        reject(new Error(`${_.capitalize(streamType)} '${err.syscall}' error: ${err.stack}`));
       });
-    }
 
-    // keep track of stdout/stderr if we haven't said not to
-    if (!opts.ignoreOutput) {
-      if (proc.stdout) {
-        proc.stdout.on('data', (data) => {
-          stdoutArr.push(data);
-        });
-      }
-      if (proc.stderr) {
-        proc.stderr.on('data', (data) => {
-          stderrArr.push(data);
-        });
+      if (opts.ignoreOutput) {
+        // https://github.com/nodejs/node/issues/4236
+        proc[streamType].on('data', () => {});
+        return;
       }
-    }
+
+      // keep track of the stream if we don't want to ignore it
+      const {chunks, maxSize} = streamProps;
+      let size = 0;
+      proc[streamType].on('data', (chunk) => {
+        chunks.push(chunk);
+        size += chunk.length;
+        while (chunks.length > 1 && size >= maxSize) {
+          size -= chunks[0].length;
+          chunks.shift();
+        }
+        if (opts.logger && _.isFunction(opts.logger.debug)) {
+          opts.logger.debug(chunk.toString());
+        }
+      });
+    };
+    handleStream('stdout', {
+      maxSize: opts.maxStdoutBufferSize,
+      chunks: stdoutArr,
+    });
+    handleStream('stderr', {
+      maxSize: opts.maxStderrBufferSize,
+      chunks: stderrArr,
+    });
 
     function getStdio (isBuffer) {
       let stdout, stderr;

package/lib/helpers.js

@@ -0,0 +1,32 @@
+import which from 'which';
+import fs from 'fs';
+
+/**
+ * Decorates ENOENT error received from a spawn system call
+ * with a more descriptive message, so it could be properly handled by a user.
+ *
+ * @param {!Error} error Original error instance. !!! The instance is mutated after
+ * this helper function invocation
+ * @param {!string} cmd Original command to execute
+ * @param {?string} cwd Optional path to the current working dir
+ * @return {Error} Mutated error instance with an improved description or an
+ * unchanged error instance
+ */
+function formatEnoent (error, cmd, cwd = null) {
+  try {
+    which.sync(cmd);
+    if (cwd) {
+      try {
+        fs.accessSync(cwd, fs.R_OK);
+      } catch (ign) {
+        error.message = `The current working directory '${cwd}' for '${cmd}' command ` +
+          `either does not exist or is not accessible`;
+      }
+    }
+  } catch (ign) {
+    error.message = `Command '${cmd}' not found. Is it installed?`;
+  }
+  return error;
+}
+
+export { formatEnoent };

package/lib/subprocess.js

@@ -2,11 +2,24 @@
 
 import { spawn } from 'child_process';
 import events from 'events';
-import through from 'through';
 const { EventEmitter } = events;
 import B from 'bluebird';
 import { quote } from 'shell-quote';
 import _ from 'lodash';
+import { formatEnoent } from './helpers';
+
+
+// This is needed to avoid memory leaks
+// when the process output is too long and contains
+// no line breaks
+const MAX_LINE_PORTION_LENGTH = 0xFFFF;
+
+function cutSuffix (str, suffixLength) {
+  return str.length > suffixLength
+    // https://bugs.chromium.org/p/v8/issues/detail?id=2869
+    ? ` ${str.substr(str.length - suffixLength)}`.substr(1)
+    : str;
+}
 
 
 class SubProcess extends EventEmitter {
@@ -87,11 +100,12 @@ class SubProcess extends EventEmitter {
       this.lastLinePortion = {stdout: '', stderr: ''};
 
       // this function handles output that we collect from the subproc
-      const handleOutput = (data) => {
+      const handleOutput = (streams) => {
+        const {stdout, stderr} = streams;
         // if we have a startDetector, run it on the output so we can resolve/
         // reject and move on from start
         try {
-          if (startDetector && startDetector(data.stdout, data.stderr)) {
+          if (startDetector && startDetector(stdout, stderr)) {
             startDetector = null;
             resolve();
           }
@@ -100,48 +114,51 @@ class SubProcess extends EventEmitter {
         }
 
         // emit the actual output for whomever's listening
-        this.emit('output', data.stdout, data.stderr);
+        this.emit('output', stdout, stderr);
 
         // we also want to emit lines, but it's more complex since output
         // comes in chunks and a line could come in two different chunks, so
         // we have logic to handle that case (using this.lastLinePortion to
         // remember a line that started but did not finish in the last chunk)
-        for (const stream of ['stdout', 'stderr']) {
-          if (!data[stream]) continue; // eslint-disable-line curly
-          let lines = data[stream].split("\n");
+        for (const [streamName, streamData] of _.toPairs(streams)) {
+          if (!streamData) continue; // eslint-disable-line curly
+          const lines = streamData.split('\n')
+            // https://bugs.chromium.org/p/v8/issues/detail?id=2869
+            .map((x) => ` ${x}`.substr(1));
           if (lines.length > 1) {
-            let retLines = lines.slice(0, -1);
-            retLines[0] = this.lastLinePortion[stream] + retLines[0];
-            this.lastLinePortion[stream] = lines[lines.length - 1];
-            this.emit(`lines-${stream}`, retLines);
-            this.emitLines(stream, retLines);
+            lines[0] = this.lastLinePortion[streamName] + lines[0];
+            this.lastLinePortion[streamName] = cutSuffix(_.last(lines), MAX_LINE_PORTION_LENGTH);
+            const resultLines = lines.slice(0, -1);
+            this.emit(`lines-${streamName}`, resultLines);
+            this.emitLines(streamName, resultLines);
           } else {
-            this.lastLinePortion[stream] += lines[0];
+            const currentPortion = cutSuffix(lines[0], MAX_LINE_PORTION_LENGTH);
+            if (this.lastLinePortion[streamName].length + currentPortion.length > MAX_LINE_PORTION_LENGTH) {
+              this.lastLinePortion[streamName] = currentPortion;
+            } else {
+              this.lastLinePortion[streamName] += currentPortion;
+            }
           }
         }
       };
 
       // if we get an error spawning the proc, reject and clean up the proc
-      this.proc.on('error', err => {
+      this.proc.on('error', (err) => {
         this.proc.removeAllListeners('exit');
         this.proc.kill('SIGINT');
 
         if (err.errno === 'ENOENT') {
-          err = new Error(`Command '${this.cmd}' not found. Is it installed?`);
+          err = formatEnoent(err, this.cmd, this.opts?.cwd);
         }
         reject(err);
       });
 
       if (this.proc.stdout) {
-        this.proc.stdout.pipe(through(stdout => {
-          handleOutput({stdout, stderr: ''});
-        }));
+        this.proc.stdout.on('data', (chunk) => handleOutput({stdout: chunk.toString(), stderr: ''}));
       }
 
       if (this.proc.stderr) {
-        this.proc.stderr.pipe(through(stderr => {
-          handleOutput({stdout: '', stderr});
-        }));
+        this.proc.stderr.on('data', (chunk) => handleOutput({stdout: '', stderr: chunk.toString()}));
       }
 
       // when the proc exits, we might still have a buffer of lines we were

package/package.json

@@ -5,7 +5,7 @@
     "child_process",
     "process management"
   ],
-  "version": "1.14.1",
+  "version": "1.16.0",
   "author": "appium",
   "license": "Apache-2.0",
   "repository": {
@@ -31,12 +31,11 @@
   ],
   "dependencies": {
     "@babel/runtime": "^7.0.0",
-    "appium-support": "^2.0.10",
     "bluebird": "^3.5.1",
     "lodash": "^4.17.4",
     "shell-quote": "^1.4.3",
     "source-map-support": "^0.5.3",
-    "through": "^2.3.8"
+    "which": "^2.0.2"
   },
   "scripts": {
     "clean": "rm -rf node_modules && rm -f package-lock.json && npm install",
@@ -54,20 +53,12 @@
     "precommit-test"
   ],
   "devDependencies": {
-    "ajv": "^6.5.3",
-    "appium-gulp-plugins": "^3.1.0",
-    "babel-eslint": "^10.0.0",
+    "appium-gulp-plugins": "^5.4.1",
+    "appium-support": "^2.0.10",
     "chai": "^4.1.2",
     "chai-as-promised": "^7.1.1",
-    "eslint": "^5.2.0",
-    "eslint-config-appium": "^3.1.0",
-    "eslint-plugin-import": "^2.2.0",
-    "eslint-plugin-mocha": "^5.0.0",
-    "eslint-plugin-promise": "^4.0.0",
+    "eslint-config-appium": "^4.0.0",
     "gulp": "^4.0.0",
     "pre-commit": "^1.2.2"
-  },
-  "greenkeeper": {
-    "ignore": []
   }
 }