A thing I spent a few hours writing and ended up not needing.

shemulator.js

/*
	sh`emulator` (shell emulator)
	by Josh Junon
	Dual license: MIT License OR public domain

	const [code, out, err] = await sh
		`cat ${process.argv[2]}`
		`wc -w`
		`rev`
		`tee /tmp/rev-word-count.txt`

	console.log({code, out, err})
	{
		code: 0,
		out: '    42',
		err: ''
	}

	Interpolation works as you'd expect; values are
	considered contiguous strings (as though they
	were double-quoted in shellscript).
*/

const child_process = require('child_process');

class StreamSink {
	constructor() {
		this.chunks = [];
		this.totalLength = 0;
		this.finishedBuffer = null;
		this.endCbs = [];
		this.streamCounts = 0;
	}

	attach(stream) {
		++this.streamCounts;

		stream.on('data', buf => {
			this.chunks.push(buf);
			this.totalLength += buf.length;
		});

		stream.on('end', () => {
			if (--this.streamCounts === 0) {
				this.finishedBuffer = Buffer.concat(this.chunks, this.totalLength);
				this.endCbs.forEach(cb => cb(this.finishedBuffer));
				delete this.endCbs; // Make any misuse or bugs fail loudly
			}
		});

		return this;
	}

	/*async*/ getBuffer() {
		return new Promise(resolve => {
			if (this.finishedBuffer) {
				return resolve(this.finishedBuffer);
			}

			this.endCbs.push(resolve);
		});
	}
};

const makeSh = (ctx = {}) => {
	if (!('stderr' in ctx)) {
		ctx.stderr = new StreamSink();
	}

	const newSh = (strings, ...args) => {
		if (!Array.isArray(strings)) {
			// strings is really a context;
			// apply whatever changes are given
			// and then return a new context.
			return makeSh(Object.assign(
				{}, ctx, strings
			));
		}

		const argv = [];

		let chunks = [];
		const commit = () => {
			if (chunks.length > 0) {
				argv.push(chunks.join(''));
				chunks = [];
			}
		};

		strings[0] = strings[0].trimStart();
		strings[strings.length - 1] = strings[strings.length - 1].trimEnd();

		for (let i = 0, len = strings.length; i < len; i++) {
			if (i > 0) {
				const arg = args[i - 1];
				chunks.push(arg.toString());
			}

			const string = strings[i];
			const pattern = /([^ \t\r\n]+)|([ \t\r\n]+)/g;

			let match;
			while ((match = pattern.exec(string))) {
				if (match[1]) {
					chunks.push(match[1]);
				} else {
					commit();
				}
			}
		}

		commit();

		if (argv.length === 0) {
			throw new Error('no arguments given');
		}

		const argv0 = argv.shift();

		const newCtx = Object.assign({}, ctx);

		/*
			A little note on the implementation:

			Technically speaking, we could pass
			the preceding process's standard
			output here to the `stdio` property.

			However, we'd have to wait for the
			`spawn` event since there wouldn't be
			a file descriptor guaranteed to back
			the stream, thus the call to spawn
			would fail.

			Thus, we opt just to eat the copy cost
			and pipe directly to the next process.

			In theory, we could wait to spawn
			processes upon `await` but that's a
			refactor for another day.

			Feel free to PR.
		*/

		const child = child_process.spawn(
			argv0,
			argv,
			{
				cwd: ctx.cwd || process.cwd(),
				env: ctx.env || process.env,
				argv0: ctx.argv0 || argv0,
				stdio: [
					(ctx.stdout ? 'pipe' : process.stdin),
					'pipe',
					'pipe'
				]
			}
		);

		let resolve;
		let reject;
		const promise = new Promise((resolve_, reject_) => {
			resolve = resolve_;
			reject = reject_;
		});

		newCtx.stdout = child.stdout;
		newCtx.statusPromise = promise;

		if (ctx.stdout) ctx.stdout.pipe(child.stdin); // otherwise, we use process.stdin above, which CAN be duped
		const stdoutSink = new StreamSink().attach(child.stdout);
		ctx.stderr.attach(child.stderr);

		child.on('error', reject);
		child.on('exit', code => resolve(code));

		const result = makeSh(newCtx);

		result.then = (...args) => (
			promise
				/*
					If Javascript's array destructuring ignored
					extra elements, we'd also pass the signal
					as the fourth element. However I can't see it
					being needed frequently enough to justify having
					it in there otherwise.
				*/
				.then(async code => ([
					(code || (ctx.statusPromise && await ctx.statusPromise) || 0),
					await stdoutSink.getBuffer(),
					await ctx.stderr.getBuffer()
				]))
				.then(...args)
		);

		result.catch = (...args) => promise.catch(...args);

		return result;
	};

	newSh.out = (...args) => {
		const shres = newSh(...args);
		const result = (...args) => shres.out(...args);
		result.then = (...args) => shres
			.then(([code, stdout, stderr]) => {
				process.stderr.write(stderr);
				if (code !== 0) process.exit(code);
				return stdout;
			})
			.then(...args);
		result.catch = (...args) => shres.catch(...args);
		return result;
	};

	return newSh;
};

module.exports = makeSh();