Increase default child process `maxBuffer`, and make configurable

[jspahrsummers]

From https://nodejs.org/api/child_process.html#child_process_child_process_exec_command_options_callback:

maxBuffer Largest amount of data in bytes allowed on stdout or stderr. If exceeded, the child process is terminated and any output is truncated. See caveat at maxBuffer and Unicode. Default: 1024 * 1024.

This (1 MiB) is a pretty low default for MCP on stdio. If exceeded, you'll see an error like the following:

stdout maxBuffer length exceeded

We probably want to bump the default, and make it overridable.

[Deeptanshu-sankhwar]

Hi @jspahrsummers, I was looking into this issue and noticed that while it references maxBuffer from exec, the SDK appears to use spawn via cross-spawn, which I believe does not apply the same buffer limit by default.

typescript-sdk/src/client/stdio.ts

Lines 1 to 5 in 5b6d35e

	import { ChildProcess, IOType } from "node:child_process";
	import spawn from "cross-spawn";
	import process from "node:process";
	import { Stream } from "node:stream";
	import { ReadBuffer, serializeMessage } from "../shared/stdio.js";

One potential concern I observed is that if a spawned tool emits a large JSON-RPC message without a terminating newline (\n), the SDK’s ReadBuffer, which waits for newline-delimited messages, may keep accumulating data indefinitely. This could result in excessive memory usage or even crashes in cases where the output is unexpectedly large or malformed.

typescript-sdk/src/shared/stdio.ts

Lines 6 to 26 in 5b6d35e

	export class ReadBuffer {
	private _buffer?: Buffer;
	append(chunk: Buffer): void {
	this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
	}
	readMessage(): JSONRPCMessage | null {
	if (!this._buffer) {
	return null;
	}
	const index = this._buffer.indexOf("\n");
	if (index === -1) {
	return null;
	}
	const line = this._buffer.toString("utf8", 0, index).replace(/\r$/, '');
	this._buffer = this._buffer.subarray(index + 1);
	return deserializeMessage(line);
	}

I was thinking a simple and effective mitigation would be to introduce a hard cap in the append() method of ReadBuffer, like so:

append(chunk: Buffer): void {
  const MAX_SIZE = 20 * 1024 * 1024;
  const newBuffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;

  if (newBuffer.length > MAX_SIZE) {
    throw new Error("ReadBuffer exceeded max size");
  }

  this._buffer = newBuffer;
}

This would ensure that even if a tool fails to emit properly delimited output, the buffer won't grow unbounded and take down the process. It doesn't solve all the issues around large or streaming payloads, but it provides a reasonable safeguard against one of the more dangerous failure modes. Would be good to hear your thoughts on whether this makes sense as a baseline fix.

[mattzcarey]

Closed as already fixed in PR #2239: the stdio read buffer now defaults to 10 MiB and is overridable via the maxBufferSize transport option, which also caps unbounded growth on newline-less output. See stdio.ts on main and stdio.ts on v1.x, wired through StdioClientTransport and StdioServerTransport.