fix: resolve E2BIG error by passing large prompts via stdin to Claude CLI

- Pass messages via stdin instead of command line arguments to avoid Linux argument length limits
- Add --input-format text flag to claude CLI command
- Update execa configuration to use stdin pipe
- Fix corresponding unit tests with proper async iterator mocking
- Resolves spawn E2BIG errors when using very large conversation histories

Author: Fovty

src/integrations/claude-code/__tests__/run.spec.ts

@@ -13,9 +13,80 @@ vi.mock("vscode", () => ({
 	},
 }))
 
+// Mock execa to test stdin behavior
+const mockExeca = vi.fn()
+const mockStdin = {
+	write: vi.fn(),
+	end: vi.fn(),
+}
+
+// Mock process that simulates successful execution
+const createMockProcess = () => {
+	let resolveProcess: (value: { exitCode: number }) => void
+	const processPromise = new Promise<{ exitCode: number }>((resolve) => {
+		resolveProcess = resolve
+	})
+
+	const mockProcess = {
+		stdin: mockStdin,
+		stdout: {
+			on: vi.fn(),
+		},
+		stderr: {
+			on: vi.fn((event, callback) => {
+				// Don't emit any stderr data in tests
+			}),
+		},
+		on: vi.fn((event, callback) => {
+			if (event === "close") {
+				// Simulate successful process completion after a short delay
+				setTimeout(() => {
+					callback(0)
+					resolveProcess({ exitCode: 0 })
+				}, 10)
+			}
+			if (event === "error") {
+				// Don't emit any errors in tests
+			}
+		}),
+		killed: false,
+		kill: vi.fn(),
+		then: processPromise.then.bind(processPromise),
+		catch: processPromise.catch.bind(processPromise),
+		finally: processPromise.finally.bind(processPromise),
+	}
+	return mockProcess
+}
+
+vi.mock("execa", () => ({
+	execa: mockExeca,
+}))
+
+// Mock readline with proper interface simulation
+let mockReadlineInterface: any = null
+
+vi.mock("readline", () => ({
+	default: {
+		createInterface: vi.fn(() => {
+			mockReadlineInterface = {
+				async *[Symbol.asyncIterator]() {
+					// Simulate Claude CLI JSON output
+					yield '{"type":"text","text":"Hello"}'
+					yield '{"type":"text","text":" world"}'
+					// Simulate end of stream - must return to terminate the iterator
+					return
+				},
+				close: vi.fn(),
+			}
+			return mockReadlineInterface
+		}),
+	},
+}))
+
 describe("runClaudeCode", () => {
 	beforeEach(() => {
 		vi.clearAllMocks()
+		mockExeca.mockReturnValue(createMockProcess())
 	})
 
 	test("should export runClaudeCode function", async () => {
@@ -34,4 +105,99 @@ describe("runClaudeCode", () => {
 		expect(Symbol.asyncIterator in result).toBe(true)
 		expect(typeof result[Symbol.asyncIterator]).toBe("function")
 	})
+
+	test("should use stdin instead of command line arguments for messages", async () => {
+		const { runClaudeCode } = await import("../run")
+		const messages = [{ role: "user" as const, content: "Hello world!" }]
+		const options = {
+			systemPrompt: "You are a helpful assistant",
+			messages,
+		}
+
+		const generator = runClaudeCode(options)
+
+		// Consume the generator to completion
+		const results = []
+		for await (const chunk of generator) {
+			results.push(chunk)
+		}
+
+		// Verify execa was called with correct arguments (no JSON.stringify(messages) in args)
+		expect(mockExeca).toHaveBeenCalledWith(
+			"claude",
+			expect.arrayContaining([
+				"-p",
+				"--input-format",
+				"text",
+				"--system-prompt",
+				"You are a helpful assistant",
+				"--verbose",
+				"--output-format",
+				"stream-json",
+				"--disallowedTools",
+				expect.any(String),
+				"--max-turns",
+				"1",
+			]),
+			expect.objectContaining({
+				stdin: "pipe",
+				stdout: "pipe",
+				stderr: "pipe",
+			}),
+		)
+
+		// Verify the arguments do NOT contain the stringified messages
+		const [, args] = mockExeca.mock.calls[0]
+		expect(args).not.toContain(JSON.stringify(messages))
+
+		// Verify messages were written to stdin
+		expect(mockStdin.write).toHaveBeenCalledWith(JSON.stringify(messages), "utf8")
+		expect(mockStdin.end).toHaveBeenCalled()
+
+		// Verify we got the expected mock output
+		expect(results).toHaveLength(2)
+		expect(results[0]).toEqual({ type: "text", text: "Hello" })
+		expect(results[1]).toEqual({ type: "text", text: " world" })
+	})
+
+	test("should include model parameter when provided", async () => {
+		const { runClaudeCode } = await import("../run")
+		const options = {
+			systemPrompt: "You are a helpful assistant",
+			messages: [{ role: "user" as const, content: "Hello" }],
+			modelId: "claude-3-5-sonnet-20241022",
+		}
+
+		const generator = runClaudeCode(options)
+
+		// Consume at least one item to trigger process spawn
+		await generator.next()
+
+		// Clean up the generator
+		await generator.return(undefined)
+
+		const [, args] = mockExeca.mock.calls[0]
+		expect(args).toContain("--model")
+		expect(args).toContain("claude-3-5-sonnet-20241022")
+	})
+
+	test("should use custom claude path when provided", async () => {
+		const { runClaudeCode } = await import("../run")
+		const options = {
+			systemPrompt: "You are a helpful assistant",
+			messages: [{ role: "user" as const, content: "Hello" }],
+			path: "/custom/path/to/claude",
+		}
+
+		const generator = runClaudeCode(options)
+
+		// Consume at least one item to trigger process spawn
+		await generator.next()
+
+		// Clean up the generator
+		await generator.return(undefined)
+
+		const [claudePath] = mockExeca.mock.calls[0]
+		expect(claudePath).toBe("/custom/path/to/claude")
+	})
 })

src/integrations/claude-code/run.ts

@@ -112,7 +112,8 @@ function runProcess({ systemPrompt, messages, path, modelId }: ClaudeCodeOptions
 
 	const args = [
 		"-p",
-		JSON.stringify(messages),
+		"--input-format",
+		"text",
 		"--system-prompt",
 		systemPrompt,
 		"--verbose",
@@ -129,8 +130,8 @@ function runProcess({ systemPrompt, messages, path, modelId }: ClaudeCodeOptions
 		args.push("--model", modelId)
 	}
 
-	return execa(claudePath, args, {
-		stdin: "ignore",
+	const child = execa(claudePath, args, {
+		stdin: "pipe",
 		stdout: "pipe",
 		stderr: "pipe",
 		env: {
@@ -142,6 +143,13 @@ function runProcess({ systemPrompt, messages, path, modelId }: ClaudeCodeOptions
 		maxBuffer: 1024 * 1024 * 1000,
 		timeout: CLAUDE_CODE_TIMEOUT,
 	})
+
+	// Stream the messages via stdin instead of command line argument
+	const messagesJson = JSON.stringify(messages)
+	child.stdin.write(messagesJson, "utf8")
+	child.stdin.end()
+
+	return child
 }
 
 function parseChunk(data: string, processState: ProcessState) {