update spawning to run as sudo/admin, and handle on stderr events

Author: TheTechsTech

README.md

@@ -56,13 +56,19 @@ installer('vim')
 });
 ```
 
-## API - spawning(command, arguments, progress, options)
+## API - spawning(command, arguments, progressOptions, options)
 
-`spawning` takes an additional argument, `progress`, its [`options`](https://nodejs.org/api/child_process.html#child_process_child_process_spawn_command_args_options) are the same as those of `child_process.spawn`.
+`Spawning` takes an additional argument, `progressOptions`, its [`options`](https://nodejs.org/api/child_process.html#child_process_child_process_spawn_command_args_options) are the same as those of `child_process.spawn` plus:
 
-* `progress`: callback handler for `stdout.on('data')` events.
+```js
+ sudo: boolean, // run as administrator
+ onerror: callable, // callback for `stderr.on('data')` event.
+ onprogress: callable, // callback for `stdout.on('data')` event.
+ // onmessage: callable, // callback for send `on('message')` event.
+ ```
+
+`Spawning` returns a promise whose result will be any output or any data return in the progress callback.
 
-It returns a promise whose result will be any output or any data return in the progress callback.
 *The progress callback will receive an object with these properties:*
 
 * `handle:` *Object* - Spawned child process instance handler.

index.js

@@ -148,28 +148,78 @@ export const where = Sys.where = function (executable) {
 }
 
 /**
- * Spawn subprocess with `Promise` features, and `progress` callback for `on('data') `event.
+ * Determine if a value is a Function
  *
- * @param {String} cmd - platform command
+ * @param {Object} value The value to test
+ * @returns {boolean} True if value is a Function, otherwise false
+ */
+function isFunction(value) {
+  return Object.prototype.toString.call(value) === '[object Function]';
+}
+
+/**
+ * Spawn subprocess with `Promise` features, and `progress` callback for `stdout.on('data') `event.
+ *
+ * @param {String} command - platform command
  * @param {Array} argument - command arguments
- * @param {Function} progress - callback for `on('data')` event.
+ * @param {Function|Object} progressOptions - either callback for `stdout.on('data')` event or spawn options.
  *```js
  * { handle: object, output: string }
  *```
- * - the callback will received object, `instance` **handle** of the spawned child processes, and any **output** data.
+ * - the callback will received an object, child process `instance` **handle**, and any **output** data.
  * - any returns will be the **`resolve()` .then()** handler.
  * @param {Object} options - Any child process `spawn` options, defaults: stdio: 'pipe'.
+ * - Additionally:
+ *```js
+ * sudo: boolean, // run as administrator
+ * onerror: callable, // callback for `stderr.on('data')` event.
+ * onprogress: callable, // callback for `stdout.on('data')` event.
+ // * onmessage: callable, // callback for `on('message')` event.
+ *```
  */
-export const spawning = Sys.spawning = function (cmd, argument = [], progress = () => { }, options = { stdio: 'pipe', }) {
+export const spawning = Sys.spawning = function (command, argument = [], progressOptions = null, options = { stdio: 'pipe', }) {
   return new Promise((resolve, reject) => {
+    options = options || {
+      stdio: 'pipe',
+      sudo: false,
+      onerror: null,
+      onprogress: null,
+      // onmessage: null,
+    };
+
+    let progress = progressOptions;
+    if (typeof progressOptions == 'object' && !isFunction(progressOptions)) {
+      options = Object.assign(options, progressOptions);
+      progress = options.onprogress || null;
+    }
+
+    let err = null;
     let output = null;
-    const child = spawn(cmd, argument, options);
+    let sudo = options.sudo || false;
+    let onerror = options.onerror || null;
+    //let onmessage = options.onmessage || null;
+
+    delete options.sudo;
+    delete options.onerror;
+    delete options.onprogress;
+    //delete options.onmessage;
+
+    if (sudo) {
+      argument = [command].concat(argument);
+      command = (process.platform == 'win32') ? join(__dirname, 'bin', 'sudo.bat') : 'sudo';
+    }
+
+    const child = spawn(command, argument, options);
     child.on('error', (data) => {
       return reject(data);
     });
 
-    child.on('close', () => {
-      return resolve(output);
+    child.on('close', (code) => {
+      if (code === 0) {
+        return resolve(output);
+      }
+
+      return reject(err, code);
     });
 
     child.on('exit', () => {
@@ -180,7 +230,7 @@ export const spawning = Sys.spawning = function (cmd, argument = [], progress =
       let input = data.toString();
       let onProgress = null
       try {
-        if (progress) {
+        if (isFunction(progress)) {
           onProgress = progress({ handle: child, output: input });
         }
       } catch (e) {
@@ -200,9 +250,19 @@ export const spawning = Sys.spawning = function (cmd, argument = [], progress =
     });
 
     child.stderr.on('data', (data) => {
-      return reject(data.toString());
-    });
+      err = data.toString();
+      if (isFunction(onerror)) {
+        err = onerror(err);
+      }
 
+      return reject(err);
+    });
+    /*
+        child.on('message', (data) => {
+          if (isFunction(onmessage))
+            onmessage(data);
+        });
+    */
     if (argument.includes('fake-js') && Object.getOwnPropertyDescriptor(process, 'platform').value == 'darwin') {
       child.kill('SIGKILL');
       return resolve('For testing only. ' + output);

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "node-sys",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Universal package installer, get the command for managing packages, or auto install any package, using one command for all platforms. Automate the installation of macOS Brew, and Windows Chocolatey package managers. A promisify child process of spawn.",
   "type": "module",
   "main": "index.js",

package.json

@@ -251,6 +251,61 @@ describe('Method: `spawning`', function () {
         done();
       });
   });
+
+  it('should return on successful install with output from `onprogress`', function (done) {
+    spawning('echo', [''], {
+      stdio: 'pipe',
+      shell: true,
+      onerror: (err) => { return 'testing: ' + err; },
+      onprogress: (object) => {
+        expect(object).to.be.a('object');
+        expect(object.handle).to.be.instanceOf(Object);
+        expect(object.output).to.be.a('string');
+        return 'hello';
+      },
+    })
+      .then(function (data) {
+        expect(data).to.be.a('string');
+        expect(data).to.equal('hello');
+        done();
+      })
+      .catch(function (err) {
+        expect(err).to.be.empty;
+        done();
+      });
+  });
+
+  it('should catch error on throw from `onprogress`', function (done) {
+    spawning('echo', [''], {
+      stdio: 'pipe',
+      shell: true,
+      onerror: (err) => { return 'testing: ' + err; },
+      onprogress: () => {
+        throw 'hello';
+      },
+    })
+      .catch(function (err) {
+        expect(err).to.equal('hello');
+        done();
+      });
+  });
+
+  it('should return on successful `Sudo` run and catch any exceptions', function (done) {
+    spawning((process.platform == 'win32' ? 'dir' : 'ls'), ['..'], {
+      stdio: 'pipe',
+      shell: true,
+      sudo: true,
+      onerror: (err) => { return 'testing: ' + err; },
+      // onmessage: (data) => { console.log('messaging: ' + data); },
+    })
+      .then(function () {
+        done();
+      })
+      .catch(function (err) {
+        expect(err).to.contains('testing: ');
+        done();
+      });
+  });
 });
 
 describe('Method: `where`', function () {