@j-o-r/sh 0.0.1 → 0.0.2

package/package.json

@@ -2,8 +2,8 @@
   "name": "@j-o-r/sh",
   "author": "Jorrit Duin <jorrit.duin@gmail.com>",
   "type": "module",
-  "version": "0.0.1",
-  "description": "Execute shell commands from javascript",
+  "version": "0.0.2",
+  "description": "Execute shell commands on Linux-based systems from javascript",
   "main": "src/sh.js",
   "engines": {
     "node": ">=18.0.0"
@@ -16,10 +16,7 @@
     "url": "https://github.com/j-o-r/sh.git"
   },
   "license": "Apache License, Version 2.0",
-  "dependencies": {
-    "ps-tree": "^1.2.0",
-    "which": "^4.0.0"
-  },
+  "dependencies": {},
   "devDependencies": {
     "@types/node": "^20.8.10",
     "uvu": "^0.5.6"
@@ -30,6 +27,8 @@
   "homepage": "https://github.com/j-o-r/sh",
   "keywords": [
     "shell",
+    "posix",
+    "linux",
     "command-line",
     "shell-script",
     "nodejs",

package/src/ProcessPromise.js

@@ -25,10 +25,11 @@
 // - The namespace has been changed from '$' to 'SH'.
 // Modified by: jorrit.duin+sh[AT]gmail.com
 
-import { spawn } from 'node:child_process';
+// import { spawn, exec } from 'node:child_process';
 import assert from 'node:assert';
-import { log, errnoMessage, exitCodeInfo, noop, parseDuration, psTree } from './utils.js';
+import { killProcesses, spawn, log, errnoMessage, exitCodeInfo, noop, parseDuration } from './utils.js';
 import ProcessOutput from './ProcessOutput.js';
+
 /** 
 * @typedef {Function} resolver
 * @param {ProcessOutput} value
@@ -42,7 +43,31 @@ import ProcessOutput from './ProcessOutput.js';
 * @param {resolver} resolve
 * @param {rejecter} reject
 */
+/**
+ * @typedef {('pipe' | 'ignore' | 'inherit' | Stream | number)} StdioOption
+ * @description Defines the stdio configuration for each of the standard streams.
+ * 
+ * - 'pipe' creates a pipe between the child process and the parent process. 
+ *   The parent end of the pipe is exposed as a property on the `ChildProcess` object.
+ * - 'ignore' indicates that the child process's corresponding stdio file descriptor will be ignored.
+ * - 'inherit' passes the corresponding stdio stream to/from the child process.
+ * - Stream object to be used for the stdio stream.
+ * - Positive integer representing a file descriptor to be used for the stdio stream.
+ */
 
+/**
+ * @typedef {Array<StdioOption>|StdioOption} StdioOptions
+ * @description 
+ * Configures the stdio streams for the child process. This can be an array or a single StdioOption.
+ * 
+ * Array Form: Specify the configuration for [stdin, stdout, stderr].
+ *   - If array length is more than 3, additional positions correspond to extra streams.
+ * Single Value: This value will be applied to stdin, stdout, and stderr.
+ * 
+ * Examples:
+ * - ['pipe', 'pipe', 'ignore']: Pipe stdin and stdout, ignore stderr.
+ * - 'inherit': Inherit all stdio streams from the parent.
+ */
 class ProcessPromise extends Promise {
 	#command = '';
 	#from = '';
@@ -51,6 +76,7 @@ class ProcessPromise extends Promise {
 	/** @type {rejecter} */
 	#reject = () => { };
 	#snapshot = {};
+	/** @type {StdioOptions} */
 	#stdio = ['inherit', 'pipe', 'pipe'];
 	#nothrow = false;
 	#quiet = false;
@@ -63,7 +89,7 @@ class ProcessPromise extends Promise {
 	* @param {PromiseConstruct} p - A function that takes two arguments, resolve and reject.
 	*/
 	constructor(p) {
-    super(p)
+		super(p)
 	}
 	/**
 	* Set the environment 
@@ -94,10 +120,10 @@ class ProcessPromise extends Promise {
 			verbose: ENV.verbose && !this.#quiet,
 		});
 		const cwd = ENV['processCwd'];
-		this.child = spawn(ENV.prefix + this.#command, {
+		const shell = ENV['shell'];
+		this.child = spawn(ENV.prefix, [this.#command], {
 			cwd,
-			// cwd: $.cwd ?? $[processCwd],
-			shell: typeof ENV.shell === 'string' ? ENV.shell : true,
+			shell,
 			stdio: this.#stdio,
 			windowsHide: true,
 			env: ENV.env,
@@ -232,23 +258,15 @@ class ProcessPromise extends Promise {
 	}
 	/**
 	* Send a KILL signal to the child process
+	* @returns {Promise<number[]>} the pid numbers that has been killed
 	*/
 	async kill(signal = 'SIGTERM') {
 		if (!this.child)
 			throw new Error('Trying to kill a process without creating one.');
 		if (!this.child.pid)
 			throw new Error('The process pid is undefined.');
-		let children = await psTree(this.child.pid);
-		for (const p of children) {
-			try {
-				process.kill(+p.PID, signal);
-			}
-			catch (e) { }
-		}
-		try {
-			process.kill(this.child.pid, signal);
-		}
-		catch (e) { }
+
+		return await killProcesses(this.child.pid, signal)
 	}
 	stdio(stdin, stdout = 'pipe', stderr = 'pipe') {
 		this.#stdio = [stdin, stdout, stderr];
@@ -287,7 +305,7 @@ class ProcessPromise extends Promise {
 		this._timeoutSignal = signal;
 		return this;
 	}
-  /**
+	/**
 	* stop execution for the next step
 	*/
 	halt() {
@@ -312,7 +330,7 @@ class ProcessPromise extends Promise {
 		// @ts-ignore
 		this.#postrun = f;
 	}
-  /**
+	/**
 	* Is this promise halted?
 	* @returns {boolean}
 	*/

package/src/sh.js

@@ -27,7 +27,6 @@
 
 import assert from 'node:assert';
 import { AsyncLocalStorage } from 'node:async_hooks';
-import which from 'which';
 import { log, parseDuration, quote, quotePowerShell, } from './utils.js';
 import ProcessPromise from './ProcessPromise.js';
 // const processCwd = Symbol('processCwd');
@@ -37,15 +36,11 @@ const defaults = {
 	processCwd: '',
 	verbose: false,
 	env: {},
-	shell: '',
+	shell: 'bash',
 	prefix: '',
 };
-if (process.platform == 'win32') {
-	defaults.shell = which.sync('powershell.exe');
-} else {
-	defaults.shell = which.sync('bash');
-	defaults.prefix = 'set -euo pipefail;';
-}
+defaults.prefix = 'set -euo pipefail;/usr/bin/env';
+
 /**
 * Escape CLI arguments
 * @retruns {string}

package/src/utils.js

@@ -25,9 +25,51 @@
 // - The namespace has been changed from '$' to 'SH'.
 // Modified by: jorrit.duin+sh[AT]gmail.com
 
-import { promisify } from 'node:util';
-import psTreeModule from 'ps-tree';
-export const psTree = promisify(psTreeModule);
+import { spawn, exec } from 'node:child_process';
+export { spawn };
+/**
+* Kills a process and all child processes of a given process ID in Linux/Posix.
+* @param {number} processPid - The process ID.
+* @param {string} signal - Signal to send.
+* @retruns {Promise<number[]>} array with killed pid numbers
+*/
+export function killProcesses(processPid, signal) {
+	const killed = [];
+	return new Promise((resolve, reject) => {
+		// Command to get child PIDs of the given process
+		const cmd = `pgrep -P ${processPid}`;
+		exec(cmd, (error, stdout, stderr) => {
+			if (error) {
+				reject(error);
+				return;
+			}
+			if (stderr) {
+				reject(new Error(stderr));
+				return;
+			}
+			const pids = stdout.split(/\r?\n/).filter(pid => pid);
+			// Kill each child process
+			try {
+				for (const pid of pids) {
+					process.kill(parseInt(pid), signal);
+					killed.push(parseInt(pid));
+				}
+			} catch (err) {
+				reject(err);
+				return;
+			}
+			// Kill the parent process after all child processes have been killed
+			try {
+				process.kill(processPid, signal);
+				killed.push(processPid);
+			} catch (err) {
+				reject(err);
+				return;
+			}
+			resolve(killed);
+		});
+	});
+}
 export function noop() { }
 export function randomId() {
 	return Math.random().toString(36).slice(2);
@@ -57,8 +99,7 @@ export function quotePowerShell(arg) {
 	}
 	return `'` + arg.replace(/'/g, "''") + `'`;
 }
-
-export function log (entry) {
+export function log(entry) {
 	switch (entry.kind) {
 		case 'cmd':
 			if (!entry.verbose) return;