Use the Terminal / TerminalProcess paradigm

Author: cte

src/activate/__tests__/registerCommands.test.ts

@@ -1,3 +1,14 @@
+// npx jest src/activate/__tests__/registerCommands.test.ts
+
+import * as vscode from "vscode"
+import { ClineProvider } from "../../core/webview/ClineProvider"
+
+import { getVisibleProviderOrLog } from "../registerCommands"
+
+jest.mock("execa", () => ({
+	execa: jest.fn(),
+}))
+
 jest.mock("vscode", () => ({
 	CodeActionKind: {
 		QuickFix: { value: "quickfix" },
@@ -8,12 +19,6 @@ jest.mock("vscode", () => ({
 	},
 }))
 
-import * as vscode from "vscode"
-import { ClineProvider } from "../../core/webview/ClineProvider"
-
-// Import the helper function from the actual file
-import { getVisibleProviderOrLog } from "../registerCommands"
-
 jest.mock("../../core/webview/ClineProvider")
 
 describe("getVisibleProviderOrLog", () => {

src/core/__tests__/Cline.test.ts

@@ -12,6 +12,10 @@ import { ClineProvider } from "../webview/ClineProvider"
 import { ApiConfiguration, ModelInfo } from "../../shared/api"
 import { ApiStreamChunk } from "../../api/transform/stream"
 
+jest.mock("execa", () => ({
+	execa: jest.fn(),
+}))
+
 // Mock RooIgnoreController
 jest.mock("../ignore/RooIgnoreController")
 

src/core/command-executors/CommandExecutor.ts

@@ -1,14 +1,15 @@
-import * as vscode from "vscode"
+import fs from "fs/promises"
 import * as path from "path"
+
+import * as vscode from "vscode"
+import { isBinaryFile } from "isbinaryfile"
+
 import { openFile } from "../../integrations/misc/open-file"
 import { UrlContentFetcher } from "../../services/browser/UrlContentFetcher"
-import { mentionRegexGlobal, formatGitSuggestion, type MentionSuggestion } from "../../shared/context-mentions"
-import fs from "fs/promises"
+import { mentionRegexGlobal } from "../../shared/context-mentions"
 import { extractTextFromFile } from "../../integrations/misc/extract-text"
-import { isBinaryFile } from "isbinaryfile"
 import { diagnosticsToProblemsString } from "../../integrations/diagnostics"
 import { getCommitInfo, getWorkingState } from "../../utils/git"
-import { getLatestTerminalOutput } from "../../integrations/terminal/get-latest-output"
 import { getWorkspacePath } from "../../utils/path"
 import { FileContextTracker } from "../context-tracking/FileContextTracker"
 
@@ -221,3 +222,50 @@ async function getWorkspaceProblems(cwd: string): Promise<string> {
 	}
 	return result
 }
+
+/**
+ * Gets the contents of the active terminal
+ * @returns The terminal contents as a string
+ */
+export async function getLatestTerminalOutput(): Promise<string> {
+	// Store original clipboard content to restore later
+	const originalClipboard = await vscode.env.clipboard.readText()
+
+	try {
+		// Select terminal content
+		await vscode.commands.executeCommand("workbench.action.terminal.selectAll")
+
+		// Copy selection to clipboard
+		await vscode.commands.executeCommand("workbench.action.terminal.copySelection")
+
+		// Clear the selection
+		await vscode.commands.executeCommand("workbench.action.terminal.clearSelection")
+
+		// Get terminal contents from clipboard
+		let terminalContents = (await vscode.env.clipboard.readText()).trim()
+
+		// Check if there's actually a terminal open
+		if (terminalContents === originalClipboard) {
+			return ""
+		}
+
+		// Clean up command separation
+		const lines = terminalContents.split("\n")
+		const lastLine = lines.pop()?.trim()
+
+		if (lastLine) {
+			let i = lines.length - 1
+
+			while (i >= 0 && !lines[i].trim().startsWith(lastLine)) {
+				i--
+			}
+
+			terminalContents = lines.slice(Math.max(i, 0)).join("\n")
+		}
+
+		return terminalContents
+	} finally {
+		// Restore original clipboard content
+		await vscode.env.clipboard.writeText(originalClipboard)
+	}
+}

src/core/command-executors/ExecaCommandExecutor.ts

@@ -1,13 +1,18 @@
 // npx jest src/core/tools/__tests__/executeCommandTool.test.ts
 
 import { describe, expect, it, jest, beforeEach } from "@jest/globals"
+
 import { Cline } from "../../Cline"
 import { formatResponse } from "../../prompts/responses"
 import { ToolUse, AskApproval, HandleError, PushToolResult, RemoveClosingTag } from "../../../shared/tools"
 import { ToolUsage } from "../../../schemas"
 import { unescapeHtmlEntities } from "../../../utils/text-normalization"
 
 // Mock dependencies
+jest.mock("execa", () => ({
+	execa: jest.fn(),
+}))
+
 jest.mock("../../Cline")
 jest.mock("../../prompts/responses")
 

src/core/command-executors/VSCodeCommandExecutor.ts

@@ -7,11 +7,11 @@ import { Cline } from "../Cline"
 import { ToolUse, AskApproval, HandleError, PushToolResult, RemoveClosingTag, ToolResponse } from "../../shared/tools"
 import { formatResponse } from "../prompts/responses"
 import { unescapeHtmlEntities } from "../../utils/text-normalization"
-import { Terminal } from "../../integrations/terminal/Terminal"
 import { telemetryService } from "../../services/telemetry/TelemetryService"
-import { ExitCodeDetails } from "../../integrations/terminal/TerminalProcess"
-import { execaCommandExecutor } from "../command-executors/ExecaCommandExecutor"
-// import { vsCodeCommandExecutor } from "../command-executors/VSCodeCommandExecutor"
+import { ExitCodeDetails, RooTerminalProcess } from "../../integrations/terminal/types"
+import { TerminalRegistry } from "../../integrations/terminal/TerminalRegistry"
+import { Terminal } from "../../integrations/terminal/Terminal"
+import { ExecaTerminal } from "../../integrations/terminal/ExecaTerminal"
 
 export async function executeCommandTool(
 	cline: Cline,
@@ -73,6 +73,7 @@ export async function executeCommand(
 	cline: Cline,
 	command: string,
 	customCwd?: string,
+	terminalProvider: "vscode" | "execa" = "vscode",
 ): Promise<[boolean, ToolResponse]> {
 	let workingDir: string
 
@@ -95,62 +96,103 @@ export async function executeCommand(
 	// a different working directory so that the model will know where the
 	// command actually executed:
 	// workingDir = terminalInfo.getCurrentWorkingDirectory()
-
 	const workingDirInfo = workingDir ? ` from '${workingDir.toPosix()}'` : ""
 
 	let userFeedback: { text?: string; images?: string[] } | undefined
-	let didContinue = false
+	let runInBackground: boolean | undefined = undefined
 	let completed = false
 	let result: string = ""
 	let exitDetails: ExitCodeDetails | undefined
 	const { terminalOutputLineLimit = 500 } = (await cline.providerRef.deref()?.getState()) ?? {}
 
-	const commandExecutor = execaCommandExecutor // vsCodeCommandExecutor
+	const debounceLineLimit = 100 // Flush after this many lines.
+	const debounceTimeoutMs = 200 // Flush after this much time inactivity (ms).
+	let buffer: string[] = []
+	let debounceTimer: NodeJS.Timeout | null = null
 
-	await commandExecutor.execute({
-		command,
-		cwd: workingDir,
-		taskId: cline.taskId,
-		onLine: async (line, process) => {
-			if (didContinue) {
-				cline.say("command_output", Terminal.compressTerminalOutput(line, terminalOutputLineLimit))
-				return
-			}
+	async function flush(process?: RooTerminalProcess) {
+		if (debounceTimer) {
+			clearTimeout(debounceTimer)
+			debounceTimer = null
+		}
+
+		if (buffer.length === 0) {
+			return
+		}
 
-			const { response, text, images } = await cline.ask("command_output", line)
+		const output = buffer.join("\n")
+		buffer = []
 
-			if (response === "yesButtonClicked") {
-				// Proceed while running.
+		result = Terminal.compressTerminalOutput(result + output, terminalOutputLineLimit)
+		const compressed = Terminal.compressTerminalOutput(output, terminalOutputLineLimit)
+		cline.say("command_output", compressed)
+
+		if (typeof runInBackground !== "undefined") {
+			return
+		}
+
+		console.log(`ask command_output: waiting for response`)
+		const { response, text, images } = await cline.ask("command_output", compressed)
+		console.log(`ask command_output =>`, response)
+
+		if (response === "yesButtonClicked") {
+			runInBackground = false
+		} else {
+			runInBackground = true
+			userFeedback = { text, images }
+		}
+
+		process?.continue()
+	}
+
+	const callbacks = {
+		onLine: async (line: string, process: RooTerminalProcess) => {
+			buffer.push(line)
+
+			if (buffer.length >= debounceLineLimit) {
+				await flush(process)
 			} else {
-				userFeedback = { text, images }
-			}
+				if (debounceTimer) {
+					clearTimeout(debounceTimer)
+				}
 
-			didContinue = true
-			process?.continue() // Continue past the await.
-		},
-		onStarted: () => {},
-		onCompleted: (output) => {
-			result = output ?? ""
-			completed = true
-		},
-		onShellExecutionComplete: (details) => {
-			exitDetails = details
+				debounceTimer = setTimeout(() => flush(process), debounceTimeoutMs)
+			}
 		},
-		onNoShellIntegration: async (message) => {
+		onCompleted: () => (completed = true),
+		onShellExecutionComplete: (details: ExitCodeDetails) => (exitDetails = details),
+		onNoShellIntegration: async (message: string) => {
 			telemetryService.captureShellIntegrationError(cline.taskId)
 			await cline.say("shell_integration_warning", message)
 		},
-	})
+	}
+
+	let terminal: Terminal | ExecaTerminal
 
-	// Wait for a short delay to ensure all messages are sent to the webview
+	if (terminalProvider === "vscode") {
+		terminal = await TerminalRegistry.getOrCreateTerminal(workingDir, !!workingDir, cline.taskId)
+		terminal.terminal.show()
+	} else {
+		terminal = new ExecaTerminal(workingDir)
+	}
+
+	await terminal.runCommand(command, callbacks)
+
+	if (debounceTimer) {
+		clearTimeout(debounceTimer)
+		debounceTimer = null
+	}
+
+	// If there are any lines in the buffer, flush them to `result`.
+	await flush()
+
+	// Wait for a short delay to ensure all messages are sent to the webview.
 	// This delay allows time for non-awaited promises to be created and
 	// for their associated messages to be sent to the webview, maintaining
 	// the correct order of messages (although the webview is smart about
 	// grouping command_output messages despite any gaps anyways).
 	await delay(50)
 
-	result = Terminal.compressTerminalOutput(result, terminalOutputLineLimit)
-
 	if (userFeedback) {
 		await cline.say("user_feedback", userFeedback.text, userFeedback.images)