@j-o-r/sh 0.0.2 → 0.0.4

package/lib/sh.js

@@ -0,0 +1,1103 @@
+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
+
+/**
+* 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
+*/
+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);
+		});
+	});
+}
+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;
+	}
+	return out + '\n';
+}
+
+// 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
+
+
+/**
+* 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 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();
+	}
+	/**
+	* 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 {('pipe' | 'ignore' | 'inherit' | 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 extends promise
+*/
+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;
+		}
+	}
+	/**
+	* 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 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;
+	}
+	/**
+	* stop execution for the next step
+	*/
+	halt() {
+		this.#halted = true;
+		return this;
+	}
+	/** 
+	* @private
+	* Set a prerun action, internal use only
+	* @param {function} f
+	*/
+	set _prerun(f) {
+		// @ts-ignore
+		this.#prerun = f;
+	}
+	/** 
+	* @private
+	* Set a postrun action, internal use only
+	* @param {function} f
+	*/
+	set _postrun(f) {
+		// @ts-ignore
+		this.#postrun = f;
+	}
+	/**
+	* Is this promise halted?
+	* @returns {boolean}
+	*/
+	get isHalted() {
+		return this.#halted;
+	}
+}
+
+// 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
+
+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.
+ *
+ * @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.
+ * @throws {Error} Throws an error if any of the string literals in `pieces` is undefined.
+ *
+ * @example
+ * const command = await SH`echo 'Hello, world!'`;
+ */
+/** @type {Shell & { (pieces: TemplateStringsArray, ...args: any[]): ProcessPromise }} */
+// @ts-ignore
+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}`);
+	}
+	let cmd = pieces[0], i = 0;
+	while (i < args.length) {
+		let s;
+		if (Array.isArray(args[i])) {
+			s = args[i].map((x) => sanitizeArg(x)).join(' ');
+		}
+		else {
+			s = sanitizeArg(args[i]);
+		}
+		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);
+	},
+});
+
+/**
+* Create a async context in an sync block
+* @param {function} callback - async function
+* @example
+* const p = within(async () => {
+*		const res = await Promise.all([
+*			SH`sleep 1; echo 1`,
+*			SH`sleep 2; echo 2`,
+*			sleep(2),
+*			SH`sleep 3; echo 3`
+*		]);
+*/
+const within = (callback) => {
+	// @ts-ignore
+	return storage.run({ ...getStore() }, callback);
+};
+/**
+* This function reads the standard input (stdin) for the current process.
+* It is used to get piped content into a script.
+* @example 
+* const content = await stdin();
+*/
+const stdin = async () => {
+	let buf = '';
+	process.stdin.setEncoding('utf8');
+	for await (const chunk of process.stdin) {
+		buf += chunk;
+	}
+	return buf;
+};
+/**
+* This function retries a command a specified number of times.
+* @example 
+* // Retry a command 3 times
+* const p = await retry(3, () => SH`curl -s https://flipwrsi`);
+* 
+* // Retry a command 3 times with an interval of 1 second between each try
+* const p = await retry(3, '1s', () => SH`curl -s https://flipwrsi`);
+* 
+* // Retry a command 3 times with irregular intervals using exponential backoff
+* const p = await retry(3, expBackoff(), () => SH`curl -s https://flipwrsi`);
+*/
+const retry = async (count, a, b) => {
+	const total = count;
+	let callback;
+	let delayStatic = 0;
+	let delayGen;
+	// @ts-ignore
+	const verbose = SH.verbose;
+	if (typeof a == 'function') {
+		callback = a;
+	}
+	else {
+		if (typeof a == 'object') {
+			delayGen = a;
+		}
+		else {
+			delayStatic = parseDuration(a);
+		}
+		assert(b);
+		callback = b;
+	}
+	let lastErr;
+	let attempt = 0;
+	while (count-- > 0) {
+		attempt++;
+		try {
+			return await callback();
+		}
+		catch (err) {
+			let delay = 0;
+			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;
+			if (delay)
+				await sleep(delay);
+		}
+	}
+	throw lastErr;
+};
+/**
+* This function pauses or "sleeps" code execution for a specified duration.
+* @param {string|number} duration - The duration to pause execution for, e.g., '100ms' or '3s'.
+* 
+* @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 sleep = (duration) => {
+	return new Promise((resolve) => {
+		setTimeout(resolve, parseDuration(duration));
+	});
+};
+/**
+* Change working directory
+* @param {string} dir
+*/
+const cd = (dir) => {
+	// @ts-ignore
+	const verbose = SH.verbose;
+	log({ kind: 'cd', dir, verbose });
+	process.chdir(dir);
+};
+function* expBackoff(max = '60s', rand = '100ms') {
+	const maxMs = parseDuration(max);
+	const randMs = parseDuration(rand);
+	let n = 1;
+	while (true) {
+		const ms = Math.floor(Math.random() * randMs);
+		yield Math.min(2 ** n++, maxMs) + ms;
+	}
+}
+
+export { SH, cd, expBackoff, retry, sleep, stdin, within };