@j-o-r/sh 0.0.4 → 1.0.0

package/lib/sh.js

@@ -1,34 +1,4 @@
-import assert from 'node:assert';
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { exec, spawn } from 'node:child_process';
-import { inspect } from 'node:util';
-
-// Copyright 2021 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-// 
-//
-// Original Source: zx
-// Link to Original Source: https://github.com/google/zx
-// Reason for Using This Code: 
-// The core functionality of this code is highly beneficial. However, certain parts of the original code 
-// were overwriting the global namespace with core libraries and variables. This was causing conflicts with 
-// other packages (for instance, fetch) and introducing unexpected elements into my code base.
-// Changes Made: 
-// - The code has been or is being reformatted to comply with ES2020 standards.
-// - Some methods were added and existing ones were modified to enhance usability.
-// - The namespace has been changed from '$' to 'SH'.
-// Modified by: jorrit.duin+sh[AT]gmail.com
+import { spawnSync, spawn, exec } from 'node:child_process';
 
 /**
 * Kills a process and all child processes of a given process ID in Linux/Posix.
@@ -36,7 +6,7 @@ import { inspect } from 'node:util';
 * @param {string} signal - Signal to send.
 * @retruns {Promise<number[]>} array with killed pid numbers
 */
-function killProcesses(processPid, signal) {
+const killProcesses = (processPid, signal) => {
 	const killed = [];
 	return new Promise((resolve, reject) => {
 		// Command to get child PIDs of the given process
@@ -72,487 +42,104 @@ function killProcesses(processPid, signal) {
 			resolve(killed);
 		});
 	});
-}
-function noop() { }
-function quote(arg) {
-	if (/^[a-z0-9/_.\-@:=]+$/i.test(arg) || arg === '') {
-		return arg;
-	}
-	return (`$'` +
-		arg
-			.replace(/\\/g, '\\\\')
-			.replace(/'/g, "\\'")
-			.replace(/\f/g, '\\f')
-			.replace(/\n/g, '\\n')
-			.replace(/\r/g, '\\r')
-			.replace(/\t/g, '\\t')
-			.replace(/\v/g, '\\v')
-			.replace(/\0/g, '\\0') +
-		`'`);
-}
-function quotePowerShell(arg) {
-	if (/^[a-z0-9/_.\-]+$/i.test(arg) || arg === '') {
-		return arg;
-	}
-	return `'` + arg.replace(/'/g, "''") + `'`;
-}
-function log(entry) {
-	switch (entry.kind) {
-		case 'cmd':
-			if (!entry.verbose) return;
-			process.stderr.write(formatCmd(entry.cmd));
-			break;
-		case 'stdout':
-		case 'stderr':
-			if (!entry.verbose) return;
-			process.stderr.write(entry.data);
-			break;
-		case 'retry':
-			if (!entry.verbose) return;
-			process.stderr.write(entry.error + '\n');
-			break;
-		case 'cd':
-			if (!entry.verbose) return;
-			process.stderr.write(`cd ${entry.dir}\n`);
-			break;
-	}
-}
-function exitCodeInfo(exitCode) {
-	return {
-		2: 'Misuse of shell builtins',
-		126: 'Invoked command cannot execute',
-		127: 'Command not found',
-		128: 'Invalid exit argument',
-		129: 'Hangup',
-		130: 'Interrupt',
-		131: 'Quit and dump core',
-		132: 'Illegal instruction',
-		133: 'Trace/breakpoint trap',
-		134: 'Process aborted',
-		135: 'Bus error: "access to undefined portion of memory object"',
-		136: 'Floating point exception: "erroneous arithmetic operation"',
-		137: 'Kill (terminate immediately)',
-		138: 'User-defined 1',
-		139: 'Segmentation violation',
-		140: 'User-defined 2',
-		141: 'Write to pipe with no one reading',
-		142: 'Signal raised by alarm',
-		143: 'Termination (request to terminate)',
-		145: 'Child process terminated, stopped (or continued*)',
-		146: 'Continue if stopped',
-		147: 'Stop executing temporarily',
-		148: 'Terminal stop signal',
-		149: 'Background process attempting to read from tty ("in")',
-		150: 'Background process attempting to write to tty ("out")',
-		151: 'Urgent data available on socket',
-		152: 'CPU time limit exceeded',
-		153: 'File size limit exceeded',
-		154: 'Signal raised by timer counting virtual time: "virtual timer expired"',
-		155: 'Profiling timer expired',
-		157: 'Pollable event',
-		159: 'Bad syscall',
-	}[exitCode || -1];
-}
-function errnoMessage(errno) {
-	if (errno === undefined) {
-		return 'Unknown error';
-	}
-	return ({
-		0: 'Success',
-		1: 'Not super-user',
-		2: 'No such file or directory',
-		3: 'No such process',
-		4: 'Interrupted system call',
-		5: 'I/O error',
-		6: 'No such device or address',
-		7: 'Arg list too long',
-		8: 'Exec format error',
-		9: 'Bad file number',
-		10: 'No children',
-		11: 'No more processes',
-		12: 'Not enough core',
-		13: 'Permission denied',
-		14: 'Bad address',
-		15: 'Block device required',
-		16: 'Mount device busy',
-		17: 'File exists',
-		18: 'Cross-device link',
-		19: 'No such device',
-		20: 'Not a directory',
-		21: 'Is a directory',
-		22: 'Invalid argument',
-		23: 'Too many open files in system',
-		24: 'Too many open files',
-		25: 'Not a typewriter',
-		26: 'Text file busy',
-		27: 'File too large',
-		28: 'No space left on device',
-		29: 'Illegal seek',
-		30: 'Read only file system',
-		31: 'Too many links',
-		32: 'Broken pipe',
-		33: 'Math arg out of domain of func',
-		34: 'Math result not representable',
-		35: 'File locking deadlock error',
-		36: 'File or path name too long',
-		37: 'No record locks available',
-		38: 'Function not implemented',
-		39: 'Directory not empty',
-		40: 'Too many symbolic links',
-		42: 'No message of desired type',
-		43: 'Identifier removed',
-		44: 'Channel number out of range',
-		45: 'Level 2 not synchronized',
-		46: 'Level 3 halted',
-		47: 'Level 3 reset',
-		48: 'Link number out of range',
-		49: 'Protocol driver not attached',
-		50: 'No CSI structure available',
-		51: 'Level 2 halted',
-		52: 'Invalid exchange',
-		53: 'Invalid request descriptor',
-		54: 'Exchange full',
-		55: 'No anode',
-		56: 'Invalid request code',
-		57: 'Invalid slot',
-		59: 'Bad font file fmt',
-		60: 'Device not a stream',
-		61: 'No data (for no delay io)',
-		62: 'Timer expired',
-		63: 'Out of streams resources',
-		64: 'Machine is not on the network',
-		65: 'Package not installed',
-		66: 'The object is remote',
-		67: 'The link has been severed',
-		68: 'Advertise error',
-		69: 'Srmount error',
-		70: 'Communication error on send',
-		71: 'Protocol error',
-		72: 'Multihop attempted',
-		73: 'Cross mount point (not really error)',
-		74: 'Trying to read unreadable message',
-		75: 'Value too large for defined data type',
-		76: 'Given log. name not unique',
-		77: 'f.d. invalid for this operation',
-		78: 'Remote address changed',
-		79: 'Can   access a needed shared lib',
-		80: 'Accessing a corrupted shared lib',
-		81: '.lib section in a.out corrupted',
-		82: 'Attempting to link in too many libs',
-		83: 'Attempting to exec a shared library',
-		84: 'Illegal byte sequence',
-		86: 'Streams pipe error',
-		87: 'Too many users',
-		88: 'Socket operation on non-socket',
-		89: 'Destination address required',
-		90: 'Message too long',
-		91: 'Protocol wrong type for socket',
-		92: 'Protocol not available',
-		93: 'Unknown protocol',
-		94: 'Socket type not supported',
-		95: 'Not supported',
-		96: 'Protocol family not supported',
-		97: 'Address family not supported by protocol family',
-		98: 'Address already in use',
-		99: 'Address not available',
-		100: 'Network interface is not configured',
-		101: 'Network is unreachable',
-		102: 'Connection reset by network',
-		103: 'Connection aborted',
-		104: 'Connection reset by peer',
-		105: 'No buffer space available',
-		106: 'Socket is already connected',
-		107: 'Socket is not connected',
-		108: "Can't send after socket shutdown",
-		109: 'Too many references',
-		110: 'Connection timed out',
-		111: 'Connection refused',
-		112: 'Host is down',
-		113: 'Host is unreachable',
-		114: 'Socket already connected',
-		115: 'Connection already in progress',
-		116: 'Stale file handle',
-		122: 'Quota exceeded',
-		123: 'No medium (in tape drive)',
-		125: 'Operation canceled',
-		130: 'Previous owner died',
-		131: 'State not recoverable',
-	}[-errno] || 'Unknown error');
-}
-function parseDuration(d) {
-	if (typeof d == 'number') {
-		if (isNaN(d) || d < 0)
-			throw new Error(`Invalid duration: "${d}".`);
-		return d;
-	}
-	else if (/\d+s/.test(d)) {
-		return +d.slice(0, -1) * 1000;
-	}
-	else if (/\d+ms/.test(d)) {
-		return +d.slice(0, -2);
-	}
-	throw new Error(`Unknown duration: "${d}".`);
-}
-function formatCmd(cmd) {
-	if (cmd == undefined)
-		return 'undefined';
-	const chars = [...cmd];
-	let out = '$ ';
-	let buf = '';
-	let ch;
-	let state = root;
-	while (state) {
-		ch = chars.shift() || 'EOF';
-		if (ch == '\n') {
-			out += style(state, buf) + '\n> ';
-			buf = '';
-			continue;
-		}
-		const next = ch == 'EOF' ? undefined : state();
-		if (next != state) {
-			out += style(state, buf);
-			buf = '';
-		}
-		state = next == root ? next() : next;
-		buf += ch;
-	}
-	function style(state, s) {
-		// if (s == '')
-		//     return '';
-		// if (reservedWords.includes(s)) {
-		//     return chalk.cyanBright(s);
-		// }
-		// if (state == word && wordCount == 0) {
-		//     wordCount++;
-		//     return chalk.greenBright(s);
-		// }
-		// if (state == syntax) {
-		//     wordCount = 0;
-		//     return chalk.cyanBright(s);
-		// }
-		// if (state == dollar)
-		//     return chalk.yellowBright(s);
-		// if (state?.name.startsWith('str'))
-		//     return chalk.yellowBright(s);
-		return s;
-	}
-	function isSyntax(ch) {
-		return '()[]{}<>;:+|&='.includes(ch);
-	}
-	function root() {
-		if (/\s/.test(ch))
-			return space;
-		if (isSyntax(ch))
-			return syntax;
-		if (/[$]/.test(ch))
-			return dollar;
-		if (/["]/.test(ch))
-			return strDouble;
-		if (/[']/.test(ch))
-			return strSingle;
-		return word;
-	}
-	function space() {
-		if (/\s/.test(ch))
-			return space;
-		return root;
-	}
-	function word() {
-		if (/[0-9a-z/_.]/i.test(ch))
-			return word;
-		return root;
-	}
-	function syntax() {
-		if (isSyntax(ch))
-			return syntax;
-		return root;
-	}
-	function dollar() {
-		if (/[']/.test(ch))
-			return str;
-		return root;
-	}
-	function str() {
-		if (/[']/.test(ch))
-			return strEnd;
-		if (/[\\]/.test(ch))
-			return strBackslash;
-		return str;
-	}
-	function strBackslash() {
-		return strEscape;
-	}
-	function strEscape() {
-		return str;
-	}
-	function strDouble() {
-		if (/["]/.test(ch))
-			return strEnd;
-		return strDouble;
-	}
-	function strSingle() {
-		if (/[']/.test(ch))
-			return strEnd;
-		return strSingle;
-	}
-	function strEnd() {
-		return root;
+};
+
+class SHExecute {
+   #proc;
+   #command = '';
+   #options = {};
+   #stdout = '';
+   #stderr = '';
+	constructor(command, options = {}) {
+		this.#command = command;
+		this.#options = options;
+		this.#proc = null;
+		this.#stdout = '';
+		this.#stderr = '';
+	}
+	runSync () {
+    let { cwd, shell, env, stdio } = this.#options;
+		return spawnSync(this.#options.prefix, [this.#command], {
+			cwd,
+			shell,
+			stdio,
+			windowsHide: true,
+			env,
+		});
 	}
-	return out + '\n';
-}
+  /**
+  * @param {string} [payload] - data to write
+  * @retuns {Promise<string>}
+  */
+	run(payload) {
+		if (payload && typeof payload !== 'string') {
+			throw new Error('Argument is not a string');
+		} 
+		let { cwd, shell, env, stdio } = this.#options;
+		if (payload) stdio = ['pipe', 'pipe', 'pipe'];
+		this.#proc = spawn(this.#options.prefix, [this.#command], {
+			cwd,
+			shell,
+			stdio,
+			windowsHide: true,
+			env,
+		});
 
-// Copyright 2021 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-// 
-//
-// Original Source: zx
-// Link to Original Source: https://github.com/google/zx
-// Reason for Using This Code: 
-// The core functionality of this code is highly beneficial. However, certain parts of the original code 
-// were overwriting the global namespace with core libraries and variables. This was causing conflicts with 
-// other packages (for instance, fetch) and introducing unexpected elements into my code base.
-// Changes Made: 
-// - The code has been or is being reformatted to comply with ES2020 standards.
-// - Some methods were added and existing ones were modified to enhance usability.
-// - The namespace has been changed from '$' to 'SH'.
-// Modified by: jorrit.duin+sh[AT]gmail.com
+		this.#proc.stdout?.on('data', (data) => {
+			this.#stdout += data;
+		});
 
+		this.#proc.stderr?.on('data', (data) => {
+			this.#stderr += data;
+		});
+    if (payload) {
+    	this.#proc.stdin.write(payload);
+      this.#proc.stdin.end();
+    }
+		return new Promise((resolve, reject) => {
+			this.#proc.on('close', (code) => {
+				if (code === 0) {
+					resolve(this.#stdout.trim());
+				} else {
+					reject(new Error(`${code}: ${this.#command} "${this.#stderr.trim()}"`));
+				}
+			});
 
-/**
-* The ProcessPromise returns a ProcessOutput even when it fails, by rejecting it.
-* The extension of the Error class is implemented to ensure compatibility when an Error is expected upon rejection.
-*/
-class ProcessOutput extends Error {
-	#code = 0;
-	#signal;
-	#stdout = '';
-	#stderr = '';
-	#combined = '';
-	/**
-	* @param {number} code - exit code
-	* @param {string} signal - SIGTERM ...
-	* @param {string} stdout - std reponse string
-	* @param {string} stderr - error reponse string
-	* @param {string} combined - stderr + stdout
-	* @param {string} message - Error message
-	*/
-	constructor(code, signal, stdout = '', stderr = '', combined = '', message = '') {
-		super(message);
-		this.#code = code;
-		this.#signal = signal;
-		this.#stdout = stdout;
-		this.#stderr = stderr;
-		this.#combined = combined;
-		this.name = 'ProcessOutput';
-	}
-	/**
-	* This string represents the standard output (stdout) from the child process.
-	* @returns {string}
-	*/
-	get stdout() {
-		return this.#stdout;
-	}
-	/**
-	* This string represents the error output (stderr) from the child process.
-	* @returns {string}
-	*/
-	get stderr() {
-		return this.#stderr;
+			this.#proc.on('error', (err) => {
+				reject(err);
+			});
+		});
 	}
+  /**
+  * @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 is an internal method that is often invoked automatically 
-	* by various JavaScript methods. 
-	* It consolidates the entire output for completeness and facilitates further processing.
-	* 
-	* @returns {string} The consolidated output as a
-	*/
-	toString() {
-		return this.#combined.trim();
+		return killProcesses(this.#proc.pid, signal);
 	}
-	/**
-	* This represents the exit code returned by the external process.
-	* @returns {number} The exit
-	*/
-	get exitCode() {
-		return this.#code;
-	}
-	/**
-	* This represents the exit signal, for example, "SIGTERM", received from the child process.
-	* @returns {string} The exit signal from the child
-	*/
-	get signal() {
-		return this.#signal;
-	}
- 	/** 
-	* This method is used for debugging purposes. It displays the current state of the object
-	* when passed to the console.log function.
-	*/
- 	[inspect.custom]() {
- 		let stringify = (s) => s.length === 0 ? "''" : inspect(s);
- 		return `ProcessOutput {
-    stdout: ${stringify(this.stdout)},
-    stderr: ${stringify(this.stderr)},
-    signal: ${inspect(this.signal)},
-    exitCode: ${(this.exitCode)}${exitCodeInfo(this.exitCode)
- 				? ' (' + exitCodeInfo(this.exitCode) + ')'
- 				: ''}
-  }`;
- 	}
 }
 
-// Copyright 2021 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-// 
-//
-// Original Source: zx
-// Link to Original Source: https://github.com/google/zx
-// Reason for Using This Code: 
-// The core functionality of this code is highly beneficial. However, certain parts of the original code 
-// were overwriting the global namespace with core libraries and variables. This was causing conflicts with 
-// other packages (for instance, fetch) and introducing unexpected elements into my code base.
-// Changes Made: 
-// - The code has been or is being reformatted to comply with ES2020 standards.
-// - Some methods were added and existing ones were modified to enhance usability.
-// - The namespace has been changed from '$' to 'SH'.
-// Modified by: jorrit.duin+sh[AT]gmail.com
-
-
-/** 
-* @typedef {Function} resolver
-* @param {ProcessOutput} value
-*/
-/** 
-* @typedef {Function} rejecter
-* @param {ProcessOutput} value
-*/
 /**
-* @typedef {Function} PromiseConstruct 
-* @param {resolver} resolve
-* @param {rejecter} reject
-*/
+ * @typedef {Object} SpawnSyncResponse
+ * @property {number} status - The exit code of the child process. A value of `0` indicates success.
+ * @property {Buffer|null} signal - The signal used to terminate the process, if any.
+ * @property {Array<string|null>} output - An array containing the standard output and standard error of the child process.
+ * @property {number} pid - The process ID of the child process.
+ * @property {Buffer|null} stdout - The standard output of the child process.
+ * @property {Buffer|null} stderr - The standard error of the child process.
+ */
+/**
+ * Default options for the execution environment.
+ *
+ * @typedef {Object} SHOptions
+ * @property {string} [cwd] - The current working directory.
+ * @property {NodeJS.ProcessEnv} [env] - The environment variables.
+ * @property {string} [shell] - The shell to use for execution.
+ * @property {string} [prefix] - The prefix commands to ensure a safe execution environment.
+ * @property {StdioOption|StdioOptions} [stdio] - The stdio configuration.
+ */
 /**
  * @typedef {('pipe' | 'ignore' | 'inherit' | number)} StdioOption
  * @description Defines the stdio configuration for each of the standard streams.
@@ -564,7 +151,6 @@ class ProcessOutput extends Error {
  * - 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 
@@ -578,287 +164,96 @@ class ProcessOutput extends Error {
  * - ['pipe', 'pipe', 'ignore']: Pipe stdin and stdout, ignore stderr.
  * - 'inherit': Inherit all stdio streams from the parent.
  */
+/**
+ * 'Code Safe' has own prop
+ *
+ * @param {any} o - object to examine
+ * @param {string} p - property to look for
+ * @returns {boolean}
+ */
+const hasProp = (o, p) => {
+	if (typeof o === 'undefined') {
+		return false;
+	}
+	return Object.prototype.hasOwnProperty.call(o, p);
+};
 
 /**
-* class extends promise
+* Merge property values while maintaining the fixed set of props in the original object
+* @param {object} predefined - original object
+* @param {object} options - object with new values
+* @retuns {object}
 */
-class ProcessPromise extends Promise {
-	#command = '';
-	#from = '';
-	/** @type {resolver} */
-	#resolve = () => { };
-	/** @type {rejecter} */
-	#reject = () => { };
-	#snapshot = {};
-	/** @type {StdioOptions} */
-	#stdio = ['inherit', 'pipe', 'pipe'];
-	#nothrow = false;
-	#quiet = false;
-	#resolved = false;
-	#halted = false;
-	#piped = false;
-	#prerun = noop;
-	#postrun = noop;
-	/**
-	* @param {PromiseConstruct} p - A function that takes two arguments, resolve and reject.
-	*/
-	constructor(p) {
-		// @ts-ignore
-		super(p);
-	}
-	/**
-	* Set the environment 
-	* and the 
-	* @param {string} cmd - Command to execute
-	* @param {string} from - Position in the codfe where this is triggred from
-	* @param {function} resolve - Promise resolve method
-	* @param {function} reject - Reject method
-	* @param {object} options - Settings (options default)
-	*/
-	_bind(cmd, from, resolve, reject, options) {
-		this.#command = cmd;
-		this.#from = from;
-		this.#resolve = resolve;
-		this.#reject = reject;
-		this.#snapshot = { ...options };
-	}
-	/**
-	* Run the promise
-	*/
-	run() {
-		const ENV = this.#snapshot;
-		if (this.child) return this; // The _run() can be called from a few places.
-		this.#prerun(); // In case $1.pipe($2), the $2 returned, and on $2._run() invoke $1._run().
-		log({
-			kind: 'cmd',
-			cmd: this.#command,
-			verbose: ENV.verbose && !this.#quiet,
-		});
-		const cwd = ENV['processCwd'];
-		const shell = ENV['shell'];
-		this.child = spawn(ENV.prefix, [this.#command], {
-			cwd,
-			shell,
-			// @ts-ignore
-			stdio: this.#stdio,
-			windowsHide: true,
-			env: ENV.env,
-		});
-		this.child.on('close', (code, signal) => {
-			let message = `exit code: ${code}`;
-			if (code != 0 || signal != null) {
-				message = `${stderr || '\n'}    at ${this.#from}`;
-				message += `\n    exit code: ${code}${exitCodeInfo(code) ? ' (' + exitCodeInfo(code) + ')' : ''}`;
-				if (signal != null) {
-					message += `\n    signal: ${signal}`;
-				}
-			}
-			let output = new ProcessOutput(code, signal, stdout, stderr, combined, message);
-			if (code === 0 || this.#nothrow) {
-				this.#resolve(output);
-			}
-			else {
-				this.#reject(output);
-			}
-			this.#resolved = true;
-		});
-		this.child.on('error', (err) => {
-			const message = `${err.message}\n` +
-				// @ts-ignore
-				`    errno: ${err.errno} (${errnoMessage(err.errno)})\n` +
-				// @ts-ignore
-				`    code: ${err.code}\n` +
-				`    at ${this.#from}`;
-			this.#reject(new ProcessOutput(null, null, stdout, stderr, combined, message));
-			this.#resolved = true;
-		});
-		let stdout = '', stderr = '', combined = '';
-		/** @param {Blob} data */
-		const onStdout = (data) => {
-			log({ kind: 'stdout', data, verbose: ENV.verbose && !this.#quiet });
-			stdout += data;
-			combined += data;
-		};
-		/** @param {Blob} data */
-		const onStderr = (data) => {
-			log({ kind: 'stderr', data, verbose: ENV.verbose && !this.#quiet });
-			stderr += data;
-			combined += data;
-		};
-		if (!this.#piped)
-			// @ts-ignore
-			this.child.stdout?.on('data', onStdout); // If process is piped, don't collect or print output.
-		// @ts-ignore
-		this.child.stderr?.on('data', onStderr); // Stderr should be printed regardless of piping.
-		this.#postrun(); // In case $1.pipe($2), after both subprocesses are running, we can pipe $1.stdout to $2.stdin.
-		if (this._timeout && this._timeoutSignal) {
-			const t = setTimeout(() => this.kill(this._timeoutSignal), this._timeout);
-			this.finally(() => clearTimeout(t)).catch(noop);
-		}
-		return this;
-	}
-	/**
-	* stdin child stream
-	* @retruns {Writeable}
-	*/
-	get stdin() {
-		this.stdio('pipe');
-		this.run();
-		assert(this.child);
-		if (this.child.stdin == null)
-			throw new Error('The stdin of subprocess is null.');
-		return this.child.stdin;
-	}
-	/**
-	* stdout child stream
-	* @retruns {Readable}
-	*/
-	get stdout() {
-		this.run();
-		assert(this.child);
-		if (this.child.stdout == null)
-			throw new Error('The stdout of subprocess is null.');
-		return this.child.stdout;
-	}
-	/**
-	* stderr child stream
-	* @retruns {Readable}
-	*/
-	get stderr() {
-		this.run();
-		assert(this.child);
-		if (this.child.stderr == null)
-			throw new Error('The stderr of subprocess is null.');
-		return this.child.stderr;
-	}
-	/**
-	* process exit code
-	* @returns {Promise<number>}
-	*/
-	get exitCode() {
-		return this.#then((p) => p.exitCode, (p) => p.exitCode);
-	}
-	#then(onfulfilled, onrejected) {
-		if (this.isHalted && !this.child) {
-			throw new Error('The process is halted!');
-		}
-		return super.then(onfulfilled, onrejected);
-	}
-	catch(onrejected) {
-		return super.catch(onrejected);
-	}
-	/**
-	* Pipe the output to the input to the next Promise
-	* @example
-	* const res = await SH`ls -FLa`.pipe(SH`grep package.json`);
-	*/
-	pipe(dest) {
-		if (typeof dest == 'string')
-			throw new Error('The pipe() method does not take strings. Forgot SH?');
-		if (this.#resolved) {
-			if (dest instanceof ProcessPromise)
-				// @ts-ignore
-				dest.stdin.end(); // In case of piped stdin, we may want to close stdin of dest as well.
-			throw new Error("The pipe() method shouldn't be called after promise is already resolved!");
-		}
-		this.#piped = true;
-		if (dest instanceof ProcessPromise) {
-			dest.stdio('pipe');
-			dest._prerun = this.run.bind(this);
-			dest._postrun = () => {
-				if (!dest.child)
-					throw new Error('Access to stdin of pipe destination without creation a subprocess.');
-				// @ts-ignore
-				this.stdout.pipe(dest.stdin);
-			};
-			return dest;
-		}
-		else {
-			// @ts-ignore
-			this._postrun = () => this.stdout.pipe(dest);
-			return this;
+const mergeOptions = (predefined, options) => {
+	// Extract the keys from the predefined object
+	const keys = Object.keys(predefined);
+
+	// Use reduce to accumulate only the predefined properties from sourceObj
+	const mergedObj = keys.reduce((acc, key) => {
+		if (hasProp(options, key)) {
+			acc[key] = options[key];
+		} else {
+			acc[key] = predefined[key];
 		}
-	}
-	/**
-	* 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.');
+		return acc;
+	}, {});
 
-		return await killProcesses(this.child.pid, signal)
-	}
-	stdio(stdin, stdout = 'pipe', stderr = 'pipe') {
-		this.#stdio = [stdin, stdout, stderr];
-		return this;
-	}
-	/**
-	* Do not throw
-	*/
-	nothrow() {
-		this.#nothrow = true;
-		return this;
-	}
-	/**
-	* supress log output
-	* SH.verbose = false; does the same
-	*/
-	quiet() {
-		this.#quiet = true;
-		return this;
-	}
-	/**
-	* Show log output in the console
-	*/
-	verbose() {
-		this._quiet = false;
-		return this;
-	}
-	/** 
-	* Set a timeout to kill a process
-	*
-	* @param {string} d - 10s, 1000ms
-	* @param {string} [signal] - default "SIGTERM" Signal to send to kill the proces
-	*/
-	timeout(d, signal = 'SIGTERM') {
-		this._timeout = parseDuration(d);
-		this._timeoutSignal = signal;
-		return this;
-	}
+	return mergedObj;
+};
+
+
+/** @type {SHOptions} */
+const defaultOptions = {
+	cwd: process.cwd(),
+	env: process.env,
+	shell: 'bash',
+	prefix: 'set -euo pipefail;/usr/bin/env',
+	stdio: ['inherit', 'pipe', 'pipe']
+};
+
+
+
+class SHDispatch {
+	#cmd = '';
+	#options = {};
+	#proc;
 	/**
-	* stop execution for the next step
+	* @param {string} cmd - cmd to execute
 	*/
-	halt() {
-		this.#halted = true;
+	constructor(cmd) {
+		this.#cmd = cmd;
+		this.#options = defaultOptions;
+	}
+  /**
+  * @param {SHOptions} options
+  * @returns {SHDispatch}
+  */
+	options(options) {
+		this.#options = mergeOptions(defaultOptions, options);
 		return this;
 	}
-	/** 
-	* @private
-	* Set a prerun action, internal use only
-	* @param {function} f
-	*/
-	set _prerun(f) {
-		// @ts-ignore
-		this.#prerun = f;
+  /** 
+  * @param {string} [payload]
+  * @returns {Promise<string>}
+  */ 
+	run(payload) {
+		this.#proc = new SHExecute(this.#cmd, this.#options);
+		return this.#proc.run(payload);
 	}
-	/** 
-	* @private
-	* Set a postrun action, internal use only
-	* @param {function} f
-	*/
-	set _postrun(f) {
+
+  /** 
+  * Works for screen takeovers like editors
+  * @returns {SpawnSyncResponse}
+  */ 
+	runSync() {
 		// @ts-ignore
-		this.#postrun = f;
+		return new SHExecute(this.#cmd, this.#options).runSync();
 	}
-	/**
-	* Is this promise halted?
-	* @returns {boolean}
-	*/
-	get isHalted() {
-		return this.#halted;
+	async kill() {
+		try {
+		  await this.#proc.kill();
+		} catch (_e) {}
+		this.#proc = undefined;
 	}
 }
 
@@ -883,60 +278,85 @@ class ProcessPromise extends Promise {
 // The core functionality of this code is highly beneficial. However, certain parts of the original code 
 // were overwriting the global namespace with core libraries and variables. This was causing conflicts with 
 // other packages (for instance, fetch) and introducing unexpected elements into my code base.
+// The main $/SH method is all there is left, with barebone Promises and readable code.
 // Changes Made: 
 // - The code has been or is being reformatted to comply with ES2020 standards.
-// - Some methods were added and existing ones were modified to enhance usability.
+// - Some methods were added and existing ones were modified or deleted to enhance usability.
+// - Most methods were deleted, 
 // - The namespace has been changed from '$' to 'SH'.
 // Modified by: jorrit.duin+sh[AT]gmail.com
 
-const storage = new AsyncLocalStorage();
 
-const defaults = {
-	processCwd: '',
-	verbose: false,
-	env: {},
-	shell: 'bash',
-	prefix: '',
-};
-defaults.prefix = 'set -euo pipefail;/usr/bin/env';
 
 /**
-* Escape CLI arguments
-* @param {string[]} arg
-* @retruns {string}
-*/
-const sanitizeArg = (arg) => {
-	const s = `${arg}`;
-	if (process.platform == 'win32') {
-		return quotePowerShell(s)
-	}
-	return quote(s);
-};
-
-const getStore = () => {
-	return storage.getStore() || defaults;
-};
-/**
- * Creates a new ProcessPromise object that represents a command to be executed.
+ * Creates a new SHDispatch object that represents a command to be executed.
  *
  * @typedef {Function} Shell
  * @property {function(Array, ...*): ProcessPromise} execute - The function to execute the command.
- * @property {boolean} verbose - A property to control verbosity.
  *
  * @param {Array} pieces - An array of string literals from a template literal.
  * @param {...*} args - The values to be interpolated into the string literals.
- * @returns {ProcessPromise} A ProcessPromise object that represents the command.
+ * @returns {SHDispatch} Trigger for the command.
  * @throws {Error} Throws an error if any of the string literals in `pieces` is undefined.
  *
  * @example
- * const command = await SH`echo 'Hello, world!'`;
+ * const command = await SH`echo 'Hello, world!'`.run();
  */
-/** @type {Shell & { (pieces: TemplateStringsArray, ...args: any[]): ProcessPromise }} */
-// @ts-ignore
+
+/**
+* escape paramater commands
+* @param {string} arg
+* @returns {string}
+*/
+const quote = (arg) => {
+	if (/^[a-z0-9/_.\-@:=]+$/i.test(arg) || arg === '') {
+		return arg;
+	}
+	return (`'` +
+		arg
+			.replace(/\\/g, '\\\\')
+			.replace(/'/g, "\\'")
+			.replace(/\f/g, '\\f')
+			.replace(/\n/g, '\\n')
+			.replace(/\r/g, '\\r')
+			.replace(/\t/g, '\\t')
+			.replace(/\v/g, '\\v')
+			.replace(/\0/g, '\\0') +
+		`'`);
+};
+/**
+* Escape CLI arguments
+* @param {string[]} arg
+* @retruns {string}
+*/
+const sanitizeArg = (arg) => {
+	const s = `${arg}`;
+	return quote(s);
+};
+
+/**
+* 4ms, 5s || 5
+* @param {number|string} d 
+* @returns {number}
+*/
+const parseDuration = (d) => {
+	if (typeof d == 'number') {
+		if (isNaN(d) || d < 0)
+			throw new Error(`Invalid duration: "${d}".`);
+		return d;
+	}
+	else if (/\d+s/.test(d)) {
+		return +d.slice(0, -1) * 1000;
+	}
+	else if (/\d+ms/.test(d)) {
+		return +d.slice(0, -2);
+	}
+	throw new Error(`Unknown duration: "${d}".`);
+};
+/** @type {Shell & { (pieces: TemplateStringsArray, ...args: *): SHDispatch }} */
 const SH = new Proxy(function(pieces, ...args) {
-	const from = new Error().stack.split(/^\s*at\s/m)[2].trim();
 	if (pieces.some((p) => p == undefined)) {
-		throw new Error(`Malformed command at ${from}`);
+		throw new Error(`Malformed command ${pieces}`);
 	}
 	let cmd = pieces[0], i = 0;
 	while (i < args.length) {
@@ -949,29 +369,8 @@ const SH = new Proxy(function(pieces, ...args) {
 		}
 		cmd += s + pieces[++i];
 	}
-	let resolve, reject;
-
-	const promise = new ProcessPromise((...args) => ([resolve, reject] = args));
-	// re-add the environment
-	defaults.processCwd = process.cwd();
-	defaults.env = process.env,
-		promise._bind(cmd, from, resolve, reject, getStore());
-	// Postpone run to allow promise configuration.
-	setImmediate(() => promise.isHalted || promise.run());
-	return promise;
-}, {
-	// this will get and set from:
-	// defaults OR storage (@see within());
-	set(_, key, value) {
-		const target = key in Function.prototype ? _ : getStore();
-		Reflect.set(target, key, value);
-		return true;
-	},
-	get(_, key) {
-		const target = key in Function.prototype ? _ : getStore();
-		return Reflect.get(target, key);
-	},
-});
+	return new SHDispatch(cmd);
+}, {});
 
 /**
 * Create a async context in an sync block
@@ -979,23 +378,23 @@ const SH = new Proxy(function(pieces, ...args) {
 * @example
 * const p = within(async () => {
 *		const res = await Promise.all([
-*			SH`sleep 1; echo 1`,
-*			SH`sleep 2; echo 2`,
+*			SH`sleep 1; echo 1`.run(),
+*			SH`sleep 2; echo 2`.run(),
 *			sleep(2),
-*			SH`sleep 3; echo 3`
+*			SH`sleep 3; echo 3`.run()
 *		]);
 */
 const within = (callback) => {
-	// @ts-ignore
-	return storage.run({ ...getStore() }, callback);
+	(async () => {
+		return await callback()
+	})();
 };
 /**
-* This function reads the standard input (stdin) for the current process.
-* It is used to get piped content into a script.
+* This function reads the standard input (stdin) from the current process.
 * @example 
 * const content = await stdin();
 */
-const stdin = async () => {
+const readIn = async () => {
 	let buf = '';
 	process.stdin.setEncoding('utf8');
 	for await (const chunk of process.stdin) {
@@ -1003,8 +402,16 @@ const stdin = async () => {
 	}
 	return buf;
 };
+
 /**
-* This function retries a command a specified number of times.
+* Retries a given asynchronous function a specified number of times with optional delays between attempts.
+*
+* @param {number} count - The number of retry attempts.
+* @param {string|expBackoff|Function} a - Either a delay duration as a string, a delay generator object, or the callback function.
+* @param {Function} [b] - The callback function to retry, required if `a` is not a function.
+* @returns {Promise<*>} - The result of the callback function if it succeeds within the retry attempts.
+* @throws {Error} - The last error encountered if all retry attempts fail.
+* 
 * @example 
 * // Retry a command 3 times
 * const p = await retry(3, () => SH`curl -s https://flipwrsi`);
@@ -1016,12 +423,11 @@ const stdin = async () => {
 * const p = await retry(3, expBackoff(), () => SH`curl -s https://flipwrsi`);
 */
 const retry = async (count, a, b) => {
-	const total = count;
+	// const total = count;
 	let callback;
 	let delayStatic = 0;
 	let delayGen;
 	// @ts-ignore
-	const verbose = SH.verbose;
 	if (typeof a == 'function') {
 		callback = a;
 	}
@@ -1036,9 +442,7 @@ const retry = async (count, a, b) => {
 		callback = b;
 	}
 	let lastErr;
-	let attempt = 0;
 	while (count-- > 0) {
-		attempt++;
 		try {
 			return await callback();
 		}
@@ -1047,13 +451,6 @@ const retry = async (count, a, b) => {
 			if (delayStatic > 0)
 				delay = delayStatic;
 			if (delayGen) delay = delayGen.next().value;
-			log({
-				verbose,
-				kind: 'retry',
-				error: ' FAIL ' +
-					` Attempt: ${attempt}${total == Infinity ? '' : `/${total}`}` +
-					(delay > 0 ? `; next in ${delay}ms` : ''),
-			});
 			lastErr = err;
 			if (count == 0)
 				break;
@@ -1069,11 +466,7 @@ const retry = async (count, a, b) => {
 * 
 * @example
 * 
-* const res = await Promise.all([
-* 	SH`sleep 2; echo 2`,  // Sleep for 2 seconds
-* 	sleep(2),             // Sleep for 2 seconds
-* 	SH`sleep 3; echo 3`   // Sleep for 3 seconds
-* ]);
+* const res = await sleep('5s');
 */
 const sleep = (duration) => {
 	return new Promise((resolve) => {
@@ -1086,10 +479,16 @@ const sleep = (duration) => {
 */
 const cd = (dir) => {
 	// @ts-ignore
-	const verbose = SH.verbose;
-	log({ kind: 'cd', dir, verbose });
 	process.chdir(dir);
 };
+/**
+ * Generates an exponential backoff time with a random jitter.
+ *
+ * @generator
+ * @param {string} [max='60s'] - The maximum backoff time in a human-readable format (e.g., '60s' for 60 seconds).
+ * @param {string} [rand='100ms'] - The maximum random jitter time in a human-readable format (e.g., '100ms' for 100 milliseconds).
+ * @yields {number} The backoff time in milliseconds.
+ */
 function* expBackoff(max = '60s', rand = '100ms') {
 	const maxMs = parseDuration(max);
 	const randMs = parseDuration(rand);
@@ -1100,4 +499,4 @@ function* expBackoff(max = '60s', rand = '100ms') {
 	}
 }
 
-export { SH, cd, expBackoff, retry, sleep, stdin, within };
+export { SH, cd, expBackoff, readIn, retry, sleep, within };