fix: handle heredoc/multiline commands in terminal tool execution (#307960)

Author: maruthang

src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/executeStrategy/basicExecuteStrategy.ts

@@ -17,6 +17,7 @@ import { ITerminalInstance } from '../../../../terminal/browser/terminal.js';
 import { createAltBufferPromise, setupRecreatingStartMarker, stripCommandEchoAndPrompt } from './strategyHelpers.js';
 import { TerminalChatAgentToolsSettingId } from '../../common/terminalChatAgentToolsConfiguration.js';
 import { isMacintosh } from '../../../../../../base/common/platform.js';
+import { isMultilineCommand } from '../runInTerminalHelpers.js';
 
 /**
  * This strategy is used when shell integration is enabled, but rich command detection was not
@@ -133,7 +134,7 @@ export class BasicExecuteStrategy extends Disposable implements ITerminalExecute
 			// occurs.
 			this._log(`Executing command line \`${commandLine}\``);
 			markerRecreation.dispose();
-			const forceBracketedPasteMode = isMacintosh;
+			const forceBracketedPasteMode = isMacintosh || isMultilineCommand(commandLine);
 			this._instance.sendText(commandLine, true, forceBracketedPasteMode);
 
 			// Wait for the next end execution event - note that this may not correspond to the actual

src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/executeStrategy/noneExecuteStrategy.ts

@@ -15,6 +15,7 @@ import { ITerminalInstance } from '../../../../terminal/browser/terminal.js';
 import { createAltBufferPromise, setupRecreatingStartMarker, stripCommandEchoAndPrompt } from './strategyHelpers.js';
 import { TerminalChatAgentToolsSettingId } from '../../common/terminalChatAgentToolsConfiguration.js';
 import { isMacintosh } from '../../../../../../base/common/platform.js';
+import { isMultilineCommand } from '../runInTerminalHelpers.js';
 
 /**
  * This strategy is used when no shell integration is available. There are very few extension APIs
@@ -85,7 +86,7 @@ export class NoneExecuteStrategy extends Disposable implements ITerminalExecuteS
 			this._log(`Executing command line \`${commandLine}\``);
 			markerRecreation.dispose();
 			const startLine = this._startMarker.value?.line;
-			const forceBracketedPasteMode = isMacintosh;
+			const forceBracketedPasteMode = isMacintosh || isMultilineCommand(commandLine);
 			this._instance.sendText(commandLine, true, forceBracketedPasteMode);
 
 			// Wait for the cursor to move past the command line before

src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/executeStrategy/richExecuteStrategy.ts

@@ -17,6 +17,7 @@ import { trackIdleOnPrompt, type ITerminalExecuteStrategy, type ITerminalExecute
 import type { IMarker as IXtermMarker } from '@xterm/xterm';
 import { createAltBufferPromise, setupRecreatingStartMarker, stripCommandEchoAndPrompt } from './strategyHelpers.js';
 import { TerminalChatAgentToolsSettingId } from '../../common/terminalChatAgentToolsConfiguration.js';
+import { isMultilineCommand } from '../runInTerminalHelpers.js';
 
 /**
  * This strategy is used when the terminal has rich shell integration/command detection is
@@ -90,7 +91,7 @@ export class RichExecuteStrategy extends Disposable implements ITerminalExecuteS
 			// Execute the command
 			this._log(`Executing command line \`${commandLine}\``);
 			markerRecreation.dispose();
-			const forceBracketedPasteMode = isMacintosh;
+			const forceBracketedPasteMode = isMacintosh || isMultilineCommand(commandLine);
 			this._instance.runCommand(commandLine, true, commandId, forceBracketedPasteMode, commandLineForMetadata);
 
 			// Wait for the terminal to idle

src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/runInTerminalHelpers.ts

@@ -87,6 +87,23 @@ export function normalizeCommandForExecution(command: string): string {
 	return command.replace(/\r\n|\r|\n/g, ' ').trim();
 }
 
+/**
+ * Whether a command spans multiple lines (heredoc, multi-statement block, etc.).
+ * Multi-line commands must be sent verbatim through bracketed paste mode so the
+ * shell treats them as a single paste instead of executing each line as it
+ * arrives.
+ *
+ * Bare line continuations (`\` immediately before a newline) are **not**
+ * considered multi-line because the shell joins them into a single logical
+ * line. Only newlines that are *not* preceded by a backslash count.
+ */
+export function isMultilineCommand(command: string): boolean {
+	// Normalize all line-ending variants to \n, then check for a newline
+	// that is not preceded by a backslash (i.e. not a line continuation).
+	const normalized = command.replace(/\r\n|\r/g, '\n');
+	return /(?<!\\)\n/.test(normalized);
+}
+
 export function generateAutoApproveActions(commandLine: string, subCommands: string[], autoApproveResult: { subCommandResults: ICommandApprovalResultWithReason[]; commandLineResult: ICommandApprovalResultWithReason }): ToolConfirmationAction[] {
 	const actions: ToolConfirmationAction[] = [];
 

src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/sendToTerminalTool.ts

@@ -18,7 +18,7 @@ import { ToolDataSource, type CountTokensCallback, type IPreparedToolInvocation,
 import { URI } from '../../../../../../base/common/uri.js';
 import { ITerminalChatService, ITerminalService } from '../../../../terminal/browser/terminal.js';
 import { getOutput } from '../outputHelpers.js';
-import { buildCommandDisplayText, normalizeCommandForExecution } from '../runInTerminalHelpers.js';
+import { buildCommandDisplayText, isMultilineCommand, normalizeCommandForExecution } from '../runInTerminalHelpers.js';
 import { RunInTerminalTool } from './runInTerminalTool.js';
 import { isSessionAutoApproveLevel } from './terminalToolAutoApprove.js';
 import { TerminalToolId } from './toolIds.js';
@@ -342,7 +342,16 @@ export class SendToTerminalTool extends Disposable implements IToolImpl {
 			};
 		}
 
-		await execution.instance.sendText(normalizeCommandForExecution(args.command), true);
+		if (isMultilineCommand(args.command)) {
+			// Multiline commands (e.g. heredocs) must preserve newlines and use
+			// bracketed paste mode so the shell treats the input as a single paste
+			// rather than executing each line independently. Intentionally skip
+			// normalizeCommandForExecution here so neither newlines nor the
+			// trailing/leading whitespace `.trim()` it performs are stripped.
+			await execution.instance.sendText(args.command, true, true);
+		} else {
+			await execution.instance.sendText(normalizeCommandForExecution(args.command), true);
+		}
 
 		await timeout(100);
 		const recentOutput = getOutput(execution.instance, undefined, { lastNLines: 5 });

src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/browser/runInTerminalHelpers.test.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { ok, strictEqual } from 'assert';
-import { generateAutoApproveActions, TRUNCATION_MESSAGE, dedupeRules, isPowerShell, truncateOutputKeepingTail, extractCdPrefix, normalizeTerminalCommandForDisplay } from '../../browser/runInTerminalHelpers.js';
+import { generateAutoApproveActions, TRUNCATION_MESSAGE, dedupeRules, isPowerShell, truncateOutputKeepingTail, extractCdPrefix, normalizeTerminalCommandForDisplay, normalizeCommandForExecution, isMultilineCommand } from '../../browser/runInTerminalHelpers.js';
 import { OperatingSystem } from '../../../../../../base/common/platform.js';
 import { ensureNoDisposablesAreLeakedInTestSuite } from '../../../../../../base/test/common/utils.js';
 import { ConfigurationTarget } from '../../../../../../platform/configuration/common/configuration.js';
@@ -513,4 +513,59 @@ suite('extractCdPrefix', () => {
 	});
 });
 
+suite('normalizeCommandForExecution', () => {
+	ensureNoDisposablesAreLeakedInTestSuite();
+
+	test('should collapse newlines to spaces for simple commands', () => {
+		strictEqual(normalizeCommandForExecution('echo hello\necho world'), 'echo hello echo world');
+	});
+
+	test('should collapse \\r\\n to spaces', () => {
+		strictEqual(normalizeCommandForExecution('echo a\r\necho b'), 'echo a echo b');
+	});
+
+	test('should collapse \\r to spaces', () => {
+		strictEqual(normalizeCommandForExecution('echo a\recho b'), 'echo a echo b');
+	});
+
+	test('should trim whitespace', () => {
+		strictEqual(normalizeCommandForExecution('  echo hello  '), 'echo hello');
+	});
+
+	test('should handle single-line command', () => {
+		strictEqual(normalizeCommandForExecution('ls -la'), 'ls -la');
+	});
+});
+
+suite('isMultilineCommand', () => {
+	ensureNoDisposablesAreLeakedInTestSuite();
+
+	test('should return true for heredoc', () => {
+		strictEqual(isMultilineCommand('cat > file.txt << \'EOF\'\nhello world\nEOF'), true);
+	});
+
+	test('should return true for multi-statement with \\n', () => {
+		strictEqual(isMultilineCommand('echo hello\necho world'), true);
+	});
+
+	test('should return true for multi-statement with \\r\\n', () => {
+		strictEqual(isMultilineCommand('echo hello\r\necho world'), true);
+	});
+
+	test('should return false for single-line command', () => {
+		strictEqual(isMultilineCommand('ls -la'), false);
+	});
+
+	test('should return false for line continuation with backslash-newline', () => {
+		strictEqual(isMultilineCommand('echo hello \\\n  world'), false);
+	});
+
+	test('should return false for line continuation with backslash-crlf', () => {
+		strictEqual(isMultilineCommand('echo hello \\\r\n  world'), false);
+	});
+
+	test('should return true when continuation and bare newline are mixed', () => {
+		strictEqual(isMultilineCommand('echo hello \\\n  world\necho done'), true);
+	});
+});
 

src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/browser/sendToTerminalTool.test.ts

@@ -57,13 +57,13 @@ suite('SendToTerminalTool', () => {
 		} as unknown as IToolInvocation;
 	}
 
-	function createMockExecution(output: string): IActiveTerminalExecution & { sentTexts: { text: string; shouldExecute: boolean }[] } {
-		const sentTexts: { text: string; shouldExecute: boolean }[] = [];
+	function createMockExecution(output: string): IActiveTerminalExecution & { sentTexts: { text: string; shouldExecute: boolean; forceBracketedPasteMode?: boolean }[] } {
+		const sentTexts: { text: string; shouldExecute: boolean; forceBracketedPasteMode?: boolean }[] = [];
 		return {
 			completionPromise: Promise.resolve({ output } as ITerminalExecuteStrategyResult),
 			instance: {
-				sendText: async (text: string, shouldExecute: boolean) => {
-					sentTexts.push({ text, shouldExecute });
+				sendText: async (text: string, shouldExecute: boolean, forceBracketedPasteMode?: boolean) => {
+					sentTexts.push({ text, shouldExecute, forceBracketedPasteMode });
 				},
 			} as unknown as ITerminalInstance,
 			getOutput: () => output,
@@ -404,4 +404,70 @@ suite('SendToTerminalTool', () => {
 		assert.ok(!message.value.includes('$(terminal)'), 'Focus Terminal link should not contain literal $(terminal)');
 		assert.ok(message.value.includes('Focus Terminal'), 'should contain Focus Terminal link text');
 	});
+
+	test('preserves newlines for heredoc commands and uses bracketed paste mode', async () => {
+		const mockExecution = createMockExecution('output');
+		RunInTerminalTool.getExecution = () => mockExecution;
+
+		const heredocCommand = 'cat > file.txt << \'EOF\'\nhello world\nEOF';
+		await tool.invoke(
+			createInvocation(KNOWN_TERMINAL_ID, heredocCommand),
+			async () => 0,
+			{ report: () => { } },
+			CancellationToken.None,
+		);
+
+		assert.strictEqual(mockExecution.sentTexts.length, 1);
+		assert.strictEqual(mockExecution.sentTexts[0].text, heredocCommand, 'heredoc command should preserve newlines');
+		assert.strictEqual(mockExecution.sentTexts[0].forceBracketedPasteMode, true, 'multiline commands should use bracketed paste mode');
+	});
+
+	test('preserves newlines for multiline commands with \\r\\n', async () => {
+		const mockExecution = createMockExecution('output');
+		RunInTerminalTool.getExecution = () => mockExecution;
+
+		const multilineCommand = 'cat > file.txt << EOF\r\ncontent\r\nEOF';
+		await tool.invoke(
+			createInvocation(KNOWN_TERMINAL_ID, multilineCommand),
+			async () => 0,
+			{ report: () => { } },
+			CancellationToken.None,
+		);
+
+		assert.strictEqual(mockExecution.sentTexts.length, 1);
+		assert.strictEqual(mockExecution.sentTexts[0].text, multilineCommand, 'multiline command with \\r\\n should preserve newlines');
+		assert.strictEqual(mockExecution.sentTexts[0].forceBracketedPasteMode, true, 'multiline commands should use bracketed paste mode');
+	});
+
+	test('single-line commands still get normalized', async () => {
+		const mockExecution = createMockExecution('output');
+		RunInTerminalTool.getExecution = () => mockExecution;
+
+		await tool.invoke(
+			createInvocation(KNOWN_TERMINAL_ID, '  echo hello  '),
+			async () => 0,
+			{ report: () => { } },
+			CancellationToken.None,
+		);
+
+		assert.strictEqual(mockExecution.sentTexts.length, 1);
+		assert.strictEqual(mockExecution.sentTexts[0].text, 'echo hello', 'single-line command should be trimmed');
+	});
+
+	test('line continuation commands are normalized, not treated as multiline', async () => {
+		const mockExecution = createMockExecution('output');
+		RunInTerminalTool.getExecution = () => mockExecution;
+
+		const continuationCommand = 'echo hello \\\n  world';
+		await tool.invoke(
+			createInvocation(KNOWN_TERMINAL_ID, continuationCommand),
+			async () => 0,
+			{ report: () => { } },
+			CancellationToken.None,
+		);
+
+		assert.strictEqual(mockExecution.sentTexts.length, 1);
+		assert.strictEqual(mockExecution.sentTexts[0].text, 'echo hello \\   world', 'line continuation should be normalized to single line');
+		assert.strictEqual(mockExecution.sentTexts[0].forceBracketedPasteMode, undefined, 'line continuation should not force bracketed paste mode');
+	});
 });