@j-o-r/sh 1.1.21 → 1.1.22

package/lib/SHExecute.js

@@ -54,20 +54,32 @@ class SHExecute {
 	#command = '';
 	/** @type {import('child_process').SpawnOptions | import('child_process').SpawnSyncOptions} */
 	#options = {};
-	#stdout = '';
-	#stderr = '';
+	#stdoutChunks = [];
+	#stderrChunks = [];
+	// Track sizes to avoid unbounded memory growth and RangeError on join/toString
+	#stdoutLen = 0;
+	#stderrLen = 0;
+	// Max bytes to buffer in memory (per stream). Remaining data is ignored.
+	#maxBuffer = 40 * 1024 * 1024; // default 40MB
+	#truncated = { stdout: false, stderr: false };
 	/**
 	* @param {string} command - linux command to be executed
 	* @param {string} prefix  - command prefix (bash, sh etc.)
-	* @param {import('child_process').SpawnOptions | import('child_process').SpawnSyncOptions} options
+	* @param {import('child_process').SpawnOptions & { maxBuffer?: number }} options
 	*/
 	constructor(command, prefix, options = {}) {
 		this.#prefix = prefix;
 		this.#command = command;
-		this.#options = options;
+		// Extract our custom option to avoid passing unknown keys to spawn/spawnSync
+		const { maxBuffer, ...spawnOpts } = options ?? {};
+		this.#maxBuffer = Number.isFinite(maxBuffer) && maxBuffer > 0 ? maxBuffer : this.#maxBuffer;
+		this.#options = spawnOpts;
 		this.#proc = null;
-		this.#stdout = '';
-		this.#stderr = '';
+		this.#stdoutChunks = [];
+		this.#stderrChunks = [];
+		this.#stdoutLen = 0;
+		this.#stderrLen = 0;
+		this.#truncated = { stdout: false, stderr: false };
 	}
 	/**
 	* @param {string} [payload] - data to write
@@ -78,10 +90,15 @@ class SHExecute {
 			throw new Error('Argument is not a string');
 		}
 		/** @type {import('node:child_process').SpawnSyncOptions} */
-		const options = this.#options;
+		const options = { ...this.#options };
 		// pipe need to be set on stdin when posting a payload
 		// @ts-ignore
-		if (payload) options['stdio'][0] = 'pipe';
+		if (payload) {
+			// clone/ensure stdio array exists
+			const stdio = Array.isArray(options.stdio) ? [...options.stdio] : ['pipe', 'pipe', 'pipe'];
+			stdio[0] = 'pipe';
+			options.stdio = stdio;
+		}
 		const input = payload || undefined;
 		if (input) {
 			options.input = input
@@ -97,17 +114,37 @@ class SHExecute {
 			throw new Error('Argument is not a string');
 		}
 		/** @type {import('node:child_process').SpawnOptions} */
-		const options = this.#options;
+		const options = { ...this.#options };
 		// pipe need to be set on stdin when posting a payload
 		// @ts-ignore
+
 		if (payload) options.stdio[0] = 'pipe';
+
+		// reset buffers for each run
+		this.#stdoutChunks = [];
+		this.#stderrChunks = [];
+		this.#stdoutLen = 0;
+		this.#stderrLen = 0;
+		this.#truncated = { stdout: false, stderr: false };
+
 		this.#proc = spawn(this.#prefix, [this.#command], options);
-		this.#proc.stdout?.on('data', (data) => {
-			this.#stdout += data;
+		this.#proc.stdout?.on('data', (chunk) => {
+			this.#stdoutLen += chunk.length;
+			if (this.#stdoutLen <= this.#maxBuffer) {
+				this.#stdoutChunks.push(chunk);
+			} else {
+				this.#truncated.stdout = true;
+				// ignore further data to cap memory; alternatively implement a ring buffer
+			}
 		});
 
-		this.#proc.stderr?.on('data', (data) => {
-			this.#stderr += data;
+		this.#proc.stderr?.on('data', (chunk) => {
+			this.#stderrLen += chunk.length;
+			if (this.#stderrLen <= this.#maxBuffer) {
+				this.#stderrChunks.push(chunk);
+			} else {
+				this.#truncated.stderr = true;
+			}
 		});
 		if (payload) {
 			this.#proc.stdin.end(payload);
@@ -123,14 +160,20 @@ class SHExecute {
 			this.#proc.on('close', (code) => {
 				if (this.#forcedKill) {
 					// Resolve without content
-					resolve();
+					resolve('');
 					return;
 				}
 				// Detached does not closes with an exitcode
 				if (code === 0 || code === null || typeof (code) === 'undefined') {
-					resolve(this.#stdout.trim());
+					const stdoutBuf = this.#stdoutChunks.length ? Buffer.concat(this.#stdoutChunks) : Buffer.alloc(0);
+					let stdout = stdoutBuf.toString('utf8').trim();
+					if (this.#truncated.stdout) stdout += '\n[stdout truncated]\n';
+					resolve(stdout);
 				} else {
-					reject(new Error(`${code}: ${this.#command} "${this.#stderr.trim()}"`));
+					const stderrBuf = this.#stderrChunks.length ? Buffer.concat(this.#stderrChunks) : Buffer.alloc(0);
+					let stderr = stderrBuf.toString('utf8').trim();
+					if (this.#truncated.stderr) stderr += '\n[stderr truncated]\n';
+					reject(new Error(`${code}: ${this.#command} "${stderr}"`));
 				}
 			});
 
@@ -165,4 +208,3 @@ class SHExecute {
 }
 
 export default SHExecute;
-

package/package.json

@@ -2,7 +2,7 @@
   "name": "@j-o-r/sh",
   "author": "Jorrit Duin <j-o-r@duin.work>",
   "type": "module",
-  "version": "1.1.21",
+  "version": "1.1.22",
   "description": "Execute shell commands on Linux-based systems from javascript",
   "main": "lib/SH.js",
   "types": "types/SH.d.ts",

package/tmp.js

@@ -0,0 +1,169 @@
+import { spawnSync, spawn, exec } from 'node:child_process';
+
+/**
+* Kills a process and all child processes of a given process ID in Linux/Posix.
+* @param {number} processPid - The process ID.
+* @param {string|number} signal - Signal to send.
+* @retruns {Promise<number[]>} array with killed pid numbers
+*/
+const 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);
+		});
+	});
+}
+
+class SHExecute {
+	#forcedKill = false;
+	/**
+	* @type {import('child_process').ChildProcess}
+	*/
+	#proc;
+	#prefix = '';
+	#command = '';
+	/** @type {import('child_process').SpawnOptions | import('child_process').SpawnSyncOptions} */
+	#options = {};
+	#stdoutChunks = [];
+	#stderrChunks = [];
+	/**
+	* @param {string} command - linux command to be executed
+	* @param {string} prefix  - command prefix (bash, sh etc.)
+	* @param {import('child_process').SpawnOptions | import('child_process').SpawnSyncOptions} options
+	*/
+	constructor(command, prefix, options = {}) {
+		this.#prefix = prefix;
+		this.#command = command;
+		this.#options = options;
+		this.#proc = null;
+		this.#stdoutChunks = [];
+		this.#stderrChunks = [];
+	}
+	/**
+	* @param {string} [payload] - data to write
+	* @retuns {Promise<object>}
+	*/
+	runSync(payload) {
+		if (payload && typeof payload !== 'string') {
+			throw new Error('Argument is not a string');
+		}
+		/** @type {import('node:child_process').SpawnSyncOptions} */
+		const options = this.#options;
+		// pipe need to be set on stdin when posting a payload
+		// @ts-ignore
+		if (payload) options['stdio'][0] = 'pipe';
+		const input = payload || undefined;
+		if (input) {
+			options.input = input
+		}
+		return spawnSync(this.#prefix, [this.#command], options);
+	}
+	/**
+	* @param {string} [payload] - data to write
+	* @retuns {Promise<string>}
+	*/
+	run(payload) {
+		if (payload && typeof payload !== 'string') {
+			throw new Error('Argument is not a string');
+		}
+		/** @type {import('node:child_process').SpawnOptions} */
+		const options = this.#options;
+		// pipe need to be set on stdin when posting a payload
+		// @ts-ignore
+		if (payload) options.stdio[0] = 'pipe';
+		this.#proc = spawn(this.#prefix, [this.#command], options);
+		this.#proc.stdout?.on('data', (data) => {
+			this.#stdoutChunks.push(data);
+		});
+
+		this.#proc.stderr?.on('data', (data) => {
+			this.#stderrChunks.push(data);
+		});
+		if (payload) {
+			this.#proc.stdin.end(payload);
+		}
+		return new Promise((resolve, reject) => {
+			// https://nodejs.org/docs/latest/api/child_process.html#optionsdetached
+			if (options.detached) {
+			setTimeout(() => {
+				resolve('');
+				this.#proc.unref();
+			}, 1000);
+			}
+			this.#proc.on('close', (code) => {
+				if (this.#forcedKill) {
+					// Resolve without content
+					resolve();
+					return;
+				}
+				// Detached does not closes with an exitcode
+				if (code === 0 || code === null || typeof (code) === 'undefined') {
+					const stdout = this.#stdoutChunks.map(chunk => chunk.toString()).join('').trim();
+					resolve(stdout);
+				} else {
+					const stderr = this.#stderrChunks.map(chunk => chunk.toString()).join('').trim();
+					reject(new Error(`${code}: \${this.#command} "${stderr}"`));
+				}
+			});
+
+			this.#proc.on('error', (err) => {
+				reject(err);
+			});
+		});
+	}
+	/**
+	* Kill this process and possible child processes
+	* @param {number | string} signal - kill signal
+	* @returns {Promise<number[]>}
+	*/
+	async kill(signal = 'SIGTERM') {
+		if (!this.#proc) throw new Error('Trying to kill a process without creating one.');
+		if (!this.#proc.pid) throw new Error('The process pid is undefined.');
+		this.#forcedKill = true;
+		let res = [];
+		try {
+			// Try to kill pid 'childs'
+			res = await killProcesses(this.#proc.pid, signal);
+		} catch (_e) { }
+		if (!res.includes(this.#proc.pid)) {
+			// Kill self if I am not allready killed
+			res.push(this.#proc.pid);
+			// @ts-ignore
+			this.#proc.kill(signal);
+		}
+		this.#proc = undefined;
+		return res;
+	}
+}
+
+export default SHExecute;

package/types/SHExecute.d.ts

@@ -3,9 +3,11 @@ declare class SHExecute {
     /**
     * @param {string} command - linux command to be executed
     * @param {string} prefix  - command prefix (bash, sh etc.)
-    * @param {import('child_process').SpawnOptions | import('child_process').SpawnSyncOptions} options
+    * @param {import('child_process').SpawnOptions & { maxBuffer?: number }} options
     */
-    constructor(command: string, prefix: string, options?: import("child_process").SpawnOptions | import("child_process").SpawnSyncOptions);
+    constructor(command: string, prefix: string, options?: import("child_process").SpawnOptions & {
+        maxBuffer?: number;
+    });
     /**
     * @param {string} [payload] - data to write
     * @retuns {Promise<object>}