feat: add command timeout and auto-skipped commands settings

packages/types/src/global-settings.ts

@@ -71,6 +71,8 @@ export const globalSettingsSchema = z.object({
 	deniedCommands: z.array(z.string()).optional(),
 	commandExecutionTimeout: z.number().optional(),
 	commandTimeoutAllowlist: z.array(z.string()).optional(),
+	commandMaxWaitTime: z.number().optional(),
+	autoSkippedCommands: z.array(z.string()).optional(),
 	preventCompletionWithOpenTodos: z.boolean().optional(),
 	allowedMaxRequests: z.number().nullish(),
 	allowedMaxCost: z.number().nullish(),
@@ -271,6 +273,8 @@ export const EVALS_SETTINGS: RooCodeSettings = {
 	allowedCommands: ["*"],
 	commandExecutionTimeout: 20,
 	commandTimeoutAllowlist: [],
+	commandMaxWaitTime: 30,
+	autoSkippedCommands: ["npm run dev", "npm start", "python -m http.server", "yarn dev", "yarn start"],
 	preventCompletionWithOpenTodos: false,
 
 	browserToolEnabled: false,

src/core/tools/executeCommandTool.ts

@@ -68,6 +68,8 @@ export async function executeCommandTool(
 				terminalOutputLineLimit = 500,
 				terminalOutputCharacterLimit = DEFAULT_TERMINAL_OUTPUT_CHARACTER_LIMIT,
 				terminalShellIntegrationDisabled = false,
+				commandMaxWaitTime = 30,
+				autoSkippedCommands = [],
 			} = providerState ?? {}
 
 			// Get command execution timeout from VSCode configuration (in seconds)
@@ -94,6 +96,8 @@ export async function executeCommandTool(
 				terminalOutputLineLimit,
 				terminalOutputCharacterLimit,
 				commandExecutionTimeout,
+				commandMaxWaitTime,
+				autoSkippedCommands,
 			}
 
 			try {
@@ -141,6 +145,8 @@ export type ExecuteCommandOptions = {
 	terminalOutputLineLimit?: number
 	terminalOutputCharacterLimit?: number
 	commandExecutionTimeout?: number
+	commandMaxWaitTime?: number
+	autoSkippedCommands?: string[]
 }
 
 export async function executeCommand(
@@ -153,6 +159,8 @@ export async function executeCommand(
 		terminalOutputLineLimit = 500,
 		terminalOutputCharacterLimit = DEFAULT_TERMINAL_OUTPUT_CHARACTER_LIMIT,
 		commandExecutionTimeout = 0,
+		commandMaxWaitTime = 30,
+		autoSkippedCommands = [],
 	}: ExecuteCommandOptions,
 ): Promise<[boolean, ToolResponse]> {
 	// Convert milliseconds back to seconds for display purposes.
@@ -249,7 +257,7 @@ export async function executeCommand(
 		workingDir = terminal.getCurrentWorkingDirectory()
 	}
 
-	const process = terminal.runCommand(command, callbacks)
+	const process = terminal.runCommand(command, callbacks, commandMaxWaitTime, autoSkippedCommands)
 	task.terminalProcess = process
 
 	// Implement command execution timeout (skip if timeout is 0).

src/core/webview/ClineProvider.ts

@@ -1815,6 +1815,8 @@ export class ClineProvider
 			openRouterImageGenerationSelectedModel,
 			openRouterUseMiddleOutTransform,
 			featureRoomoteControlEnabled,
+			commandMaxWaitTime,
+			autoSkippedCommands,
 		} = await this.getState()
 
 		let cloudOrganizations: CloudOrganizationMembership[] = []
@@ -1964,6 +1966,8 @@ export class ClineProvider
 			openRouterImageGenerationSelectedModel,
 			openRouterUseMiddleOutTransform,
 			featureRoomoteControlEnabled,
+			commandMaxWaitTime: commandMaxWaitTime ?? 30,
+			autoSkippedCommands: autoSkippedCommands ?? [],
 		}
 	}
 
@@ -2195,6 +2199,8 @@ export class ClineProvider
 					return false
 				}
 			})(),
+			commandMaxWaitTime: stateValues.commandMaxWaitTime ?? 30,
+			autoSkippedCommands: stateValues.autoSkippedCommands ?? [],
 		}
 	}
 

src/integrations/terminal/BaseTerminal.ts

@@ -38,7 +38,12 @@ export abstract class BaseTerminal implements RooTerminal {
 
 	abstract isClosed(): boolean
 
-	abstract runCommand(command: string, callbacks: RooTerminalCallbacks): RooTerminalProcessResultPromise
+	abstract runCommand(
+		command: string,
+		callbacks: RooTerminalCallbacks,
+		commandMaxWaitTime?: number,
+		autoSkippedCommands?: string[],
+	): RooTerminalProcessResultPromise
 
 	/**
 	 * Sets the active stream for this terminal and notifies the process

src/integrations/terminal/ExecaTerminal.ts

@@ -15,7 +15,12 @@ export class ExecaTerminal extends BaseTerminal {
 		return false
 	}
 
-	public override runCommand(command: string, callbacks: RooTerminalCallbacks): RooTerminalProcessResultPromise {
+	public override runCommand(
+		command: string,
+		callbacks: RooTerminalCallbacks,
+		commandMaxWaitTime?: number,
+		autoSkippedCommands?: string[],
+	): RooTerminalProcessResultPromise {
 		this.busy = true
 
 		const process = new ExecaTerminalProcess(this)
@@ -30,6 +35,7 @@ export class ExecaTerminal extends BaseTerminal {
 		const promise = new Promise<void>((resolve, reject) => {
 			process.once("continue", () => resolve())
 			process.once("error", (error) => reject(error))
+			// Note: ExecaTerminalProcess doesn't support timeout yet, but we maintain the interface
 			process.run(command)
 		})
 

src/integrations/terminal/Terminal.ts

@@ -40,7 +40,12 @@ export class Terminal extends BaseTerminal {
 		return this.terminal.exitStatus !== undefined
 	}
 
-	public override runCommand(command: string, callbacks: RooTerminalCallbacks): RooTerminalProcessResultPromise {
+	public override runCommand(
+		command: string,
+		callbacks: RooTerminalCallbacks,
+		commandMaxWaitTime?: number,
+		autoSkippedCommands?: string[],
+	): RooTerminalProcessResultPromise {
 		// We set busy before the command is running because the terminal may be
 		// waiting on terminal integration, and we must prevent another instance
 		// from selecting the terminal for use during that time.
@@ -59,6 +64,19 @@ export class Terminal extends BaseTerminal {
 		process.once("shell_execution_complete", (details) => callbacks.onShellExecutionComplete(details, process))
 		process.once("no_shell_integration", (msg) => callbacks.onNoShellIntegration?.(msg, process))
 
+		// Add handlers for timeout and background command events
+		process.once("command_timeout", (cmd: string) => {
+			console.log(`[Terminal] Command timeout for: ${cmd}`)
+			callbacks.onLine?.(
+				`\n[Command timeout reached - continuing with other tasks while this runs in background]\n`,
+				process,
+			)
+		})
+		process.once("background_command", (cmd: string) => {
+			console.log(`[Terminal] Background command started: ${cmd}`)
+			callbacks.onLine?.(`\n[Running in background - continuing with other tasks]\n`, process)
+		})
+
 		const promise = new Promise<void>((resolve, reject) => {
 			// Set up event handlers
 			process.once("continue", () => resolve())
@@ -75,8 +93,8 @@ export class Terminal extends BaseTerminal {
 					// Clean up temporary directory if shell integration is available, zsh did its job:
 					ShellIntegrationManager.zshCleanupTmpDir(this.id)
 
-					// Run the command in the terminal
-					process.run(command)
+					// Run the command in the terminal with timeout settings
+					process.run(command, commandMaxWaitTime, autoSkippedCommands)
 				})
 				.catch(() => {
 					console.log(`[Terminal ${this.id}] Shell integration not available. Command execution aborted.`)

src/integrations/terminal/TerminalProcess.ts

@@ -16,6 +16,10 @@ import { Terminal } from "./Terminal"
 
 export class TerminalProcess extends BaseTerminalProcess {
 	private terminalRef: WeakRef<Terminal>
+	private commandTimeout?: NodeJS.Timeout
+	private commandMaxWaitTime: number = 30000 // Default 30 seconds
+	private autoSkippedCommands: string[] = []
+	private isBackgroundCommand: boolean = false
 
 	constructor(terminal: Terminal) {
 		super()
@@ -44,9 +48,20 @@ export class TerminalProcess extends BaseTerminalProcess {
 		return terminal
 	}
 
-	public override async run(command: string) {
+	public override async run(command: string, commandMaxWaitTime?: number, autoSkippedCommands?: string[]) {
 		this.command = command
 
+		// Update settings if provided
+		if (commandMaxWaitTime !== undefined) {
+			this.commandMaxWaitTime = commandMaxWaitTime * 1000 // Convert to milliseconds
+		}
+		if (autoSkippedCommands !== undefined) {
+			this.autoSkippedCommands = autoSkippedCommands
+		}
+
+		// Check if this command should run in background
+		this.isBackgroundCommand = this.shouldRunInBackground(command)
+
 		const terminal = this.terminal.terminal
 
 		const isShellIntegrationAvailable = terminal.shellIntegration && terminal.shellIntegration.executeCommand
@@ -134,6 +149,30 @@ export class TerminalProcess extends BaseTerminalProcess {
 
 		this.isHot = true
 
+		// Set up timeout for long-running commands if not a background command
+		if (!this.isBackgroundCommand && this.commandMaxWaitTime > 0) {
+			this.commandTimeout = setTimeout(() => {
+				console.log(
+					`[TerminalProcess] Command timeout reached after ${this.commandMaxWaitTime / 1000} seconds for: ${command}`,
+				)
+
+				// Emit event to allow Roo to continue with other tasks
+				this.emit("command_timeout", command)
+
+				// Don't abort the command, just allow Roo to continue
+				// The command will continue running in the background
+				this.isBackgroundCommand = true
+			}, this.commandMaxWaitTime)
+		}
+
+		// If it's a background command, emit immediately to allow Roo to continue
+		if (this.isBackgroundCommand) {
+			console.log(`[TerminalProcess] Running command in background: ${command}`)
+			setTimeout(() => {
+				this.emit("background_command", command)
+			}, 100) // Small delay to ensure command starts
+		}
+
 		// Wait for stream to be available
 		let stream: AsyncIterable<string>
 
@@ -208,6 +247,12 @@ export class TerminalProcess extends BaseTerminalProcess {
 		// Set streamClosed immediately after stream ends.
 		this.terminal.setActiveStream(undefined)
 
+		// Clear timeout if command completed before timeout
+		if (this.commandTimeout) {
+			clearTimeout(this.commandTimeout)
+			this.commandTimeout = undefined
+		}
+
 		// Wait for shell execution to complete.
 		await shellExecutionComplete
 
@@ -464,4 +509,24 @@ export class TerminalProcess extends BaseTerminalProcess {
 
 		return match133 !== undefined ? match133 : match633
 	}
+
+	/**
+	 * Check if a command should run in the background based on patterns
+	 */
+	private shouldRunInBackground(command: string): boolean {
+		if (!this.autoSkippedCommands || this.autoSkippedCommands.length === 0) {
+			return false
+		}
+
+		const lowerCommand = command.toLowerCase()
+		return this.autoSkippedCommands.some((pattern) => {
+			const lowerPattern = pattern.toLowerCase()
+			// Support wildcards in patterns
+			if (lowerPattern.includes("*")) {
+				const regex = new RegExp(lowerPattern.replace(/\*/g, ".*"))
+				return regex.test(lowerCommand)
+			}
+			return lowerCommand.includes(lowerPattern)
+		})
+	}
 }