Fix zero maxBuffer allowing unbounded synchronous output

`maxBuffer: 0` disables the limit of `child_process.spawnSync()`, so the subprocess' output was never limited. A zero value must reject the first byte, like it does with asynchronous methods.

Author: sindresorhus

lib/io/max-buffer.js

@@ -63,7 +63,8 @@ const getMaxBufferInfo = (error, maxBuffer) => {
 // The native `maxBuffer` option passed to `spawnSync()` does not allow differentiating values per file descriptor, so we use `stdout`'s.
 // Since each other file descriptor's own limit is capped by `stdout`'s, this is also the highest one.
 // Node.js applies it to the total output of all piped file descriptors, not to each of them. When it is hit, the subprocess is killed and a `ENOBUFS` error is thrown.
-export const getMaxBufferSync = ([, stdoutMaxBuffer]) => stdoutMaxBuffer;
+// Node.js disables its limit at zero, so use the smallest positive value to reject the first output byte.
+export const getMaxBufferSync = ([, stdoutMaxBuffer]) => stdoutMaxBuffer === 0 ? Number.MIN_VALUE : stdoutMaxBuffer;
 
 // File descriptors with a limit lower than `spawnSync()`'s native `maxBuffer` are enforced from the output, after the subprocess exits.
 // Since no native error was thrown, we create the `ENOBUFS` error ourselves.

test/io/max-buffer.js

@@ -369,6 +369,65 @@ test('maxBuffer.fd10 is invalid, sync', () => testInvalidFd('fd10', execaSync));
 // These tests need the subprocess to have written its output before the timeout kills it, which is only guaranteed if the timeout leaves room for the subprocess to start. On a busy machine, starting Node.js can take over a second.
 const SYNC_TIMEOUT = 1e4;
 
+test('maxBuffer 0 terminates on the first output byte before timeout, sync', () => {
+	const error = assertThrows(() => {
+		execaSync('max-buffer-forever.js', ['1', '1'], {timeout: SYNC_TIMEOUT, maxBuffer: 0});
+	}, maxBufferCodeSync);
+	assert.equal(error.timedOut, false);
+	assert.equal(error.isMaxBuffer, true);
+	assert.equal(error.stdout, '');
+	assertErrorMessage(error.shortMessage, {execaMethod: execaSync, length: 0});
+});
+
+const testZeroMaxBufferSync = (fdNumber, maxBuffer, encoding = 'utf8') => {
+	const error = execaSync('max-buffer-forever.js', [`${fdNumber}`, '1'], {
+		...fullStdio,
+		timeout: SYNC_TIMEOUT,
+		maxBuffer,
+		encoding,
+		reject: false,
+	});
+	assert.equal(error.code, 'ENOBUFS');
+	assert.equal(error.failed, true);
+	assert.equal(error.timedOut, false);
+	assert.equal(error.isMaxBuffer, true);
+	assert.deepEqual(error.stdio[fdNumber], encoding === 'buffer' ? new Uint8Array() : '');
+	assertErrorMessage(error.shortMessage, {execaMethod: execaSync, fdNumber, length: 0});
+};
+
+test('maxBuffer 0 terminates on the first stderr byte before timeout, sync', () => testZeroMaxBufferSync(2, 0));
+test('maxBuffer 0 terminates on the first fd3 byte before timeout with binary output, sync', () => testZeroMaxBufferSync(3, 0, 'buffer'));
+test('maxBuffer 0 terminates on the first output byte with stdout-specific limit, sync', () => testZeroMaxBufferSync(1, {stdout: 0}));
+test('maxBuffer 0 terminates on the first fd3 byte with fd1-specific limit, sync', () => testZeroMaxBufferSync(3, {fd1: 0}));
+
+const testZeroMaxBufferEmptySync = (maxBuffer, encoding = 'utf8') => {
+	const {failed, isMaxBuffer, stdout} = execaSync('empty.js', {maxBuffer, encoding});
+	assert.equal(failed, false);
+	assert.equal(isMaxBuffer, false);
+	assert.deepEqual(stdout, encoding === 'buffer' ? new Uint8Array() : '');
+};
+
+test('maxBuffer 0 allows empty text output, sync', () => testZeroMaxBufferEmptySync(0));
+test('maxBuffer 0 allows empty binary output, sync', () => testZeroMaxBufferEmptySync(0, 'buffer'));
+test('maxBuffer 0 allows empty output with stdout-specific limit, sync', () => testZeroMaxBufferEmptySync({stdout: 0}));
+
+test('maxBuffer small positive limit allows exactly one byte, sync', () => {
+	const {failed, isMaxBuffer, stdout} = execaSync('max-buffer.js', ['1', '1'], {maxBuffer: 1});
+	assert.equal(failed, false);
+	assert.equal(isMaxBuffer, false);
+	assert.equal(stdout, '.');
+});
+
+test('maxBuffer small positive fractional limit rejects the first byte, sync', () => {
+	const error = assertThrows(() => {
+		execaSync('max-buffer-forever.js', ['1', '1'], {timeout: SYNC_TIMEOUT, maxBuffer: 0.5});
+	}, maxBufferCodeSync);
+	assert.equal(error.timedOut, false);
+	assert.equal(error.isMaxBuffer, true);
+	assert.equal(error.stdout, '');
+	assertErrorMessage(error.shortMessage, {execaMethod: execaSync, length: 0.5});
+});
+
 // A file descriptor limit lower than `maxBuffer.stdout` does not stop the subprocess with synchronous methods, so the subprocess can still time out afterwards
 const testMaxBufferTimeoutSync = (fdNumber, fdName) => {
 	const length = 3;