More fixes

Author: cte

src/core/auto-approval/index.ts

@@ -1,6 +1,7 @@
-import { type ClineAsk, type McpServerUse, isNonBlockingAsk } from "@roo-code/types"
+import { type ClineAsk, type McpServerUse, type FollowUpData, isNonBlockingAsk } from "@roo-code/types"
 
 import type { ClineSayTool, ExtensionState } from "../../shared/ExtensionMessage"
+import { ClineAskResponse } from "../../shared/WebviewMessage"
 
 import { isWriteToolAction, isReadOnlyToolAction } from "./tools"
 import { isMcpToolAlwaysAllowed } from "./mcp"
@@ -25,77 +26,106 @@ export type AutoApprovalStateOptions =
 	| "alwaysAllowReadOnlyOutsideWorkspace" // For `alwaysAllowReadOnly`.
 	| "alwaysAllowWriteOutsideWorkspace" // For `alwaysAllowWrite`.
 	| "alwaysAllowWriteProtected"
+	| "followupAutoApproveTimeoutMs" // For `alwaysAllowFollowupQuestions`.
 	| "mcpServers" // For `alwaysAllowMcp`.
 	| "allowedCommands" // For `alwaysAllowExecute`.
 	| "deniedCommands"
 
-export type CheckAutoApprovalResult = "approve" | "deny" | "ask"
+export type CheckAutoApprovalResult =
+	| { decision: "approve" }
+	| { decision: "deny" }
+	| { decision: "ask" }
+	| {
+			decision: "timeout"
+			timeout: number
+			fn: () => { askResponse: ClineAskResponse; text?: string; images?: string[] }
+	  }
 
 export async function checkAutoApproval({
 	state,
 	ask,
 	text,
 	isProtected,
 }: {
-	state: Pick<ExtensionState, AutoApprovalState | AutoApprovalStateOptions>
+	state?: Pick<ExtensionState, AutoApprovalState | AutoApprovalStateOptions>
 	ask: ClineAsk
 	text?: string
 	isProtected?: boolean
 }): Promise<CheckAutoApprovalResult> {
 	if (isNonBlockingAsk(ask)) {
-		return "approve"
+		return { decision: "approve" }
 	}
 
-	if (!state.autoApprovalEnabled) {
-		return "ask"
+	if (!state || !state.autoApprovalEnabled) {
+		return { decision: "ask" }
 	}
 
-	// Note: The `alwaysApproveResubmit` check is already handled in `Task`.
-
 	if (ask === "followup") {
-		return state.alwaysAllowFollowupQuestions === true ? "approve" : "ask"
+		if (state.alwaysAllowFollowupQuestions === true) {
+			try {
+				const suggestion = (JSON.parse(text || "{}") as FollowUpData).suggest?.[0]
+
+				if (
+					suggestion &&
+					typeof state.followupAutoApproveTimeoutMs === "number" &&
+					state.followupAutoApproveTimeoutMs > 0
+				) {
+					return {
+						decision: "timeout",
+						timeout: state.followupAutoApproveTimeoutMs,
+						fn: () => ({ askResponse: "messageResponse", text: suggestion.answer }),
+					}
+				} else {
+					return { decision: "ask" }
+				}
+			} catch (error) {
+				return { decision: "ask" }
+			}
+		} else {
+			return { decision: "ask" }
+		}
 	}
 
 	if (ask === "browser_action_launch") {
-		return state.alwaysAllowBrowser === true ? "approve" : "ask"
+		return state.alwaysAllowBrowser === true ? { decision: "approve" } : { decision: "ask" }
 	}
 
 	if (ask === "use_mcp_server") {
 		if (!text) {
-			return "ask"
+			return { decision: "ask" }
 		}
 
 		try {
 			const mcpServerUse = JSON.parse(text) as McpServerUse
 
 			if (mcpServerUse.type === "use_mcp_tool") {
 				return state.alwaysAllowMcp === true && isMcpToolAlwaysAllowed(mcpServerUse, state.mcpServers)
-					? "approve"
-					: "ask"
+					? { decision: "approve" }
+					: { decision: "ask" }
 			} else if (mcpServerUse.type === "access_mcp_resource") {
-				return state.alwaysAllowMcp === true ? "approve" : "ask"
+				return state.alwaysAllowMcp === true ? { decision: "approve" } : { decision: "ask" }
 			}
 		} catch (error) {
-			return "ask"
+			return { decision: "ask" }
 		}
 
-		return "ask"
+		return { decision: "ask" }
 	}
 
 	if (ask === "command") {
 		if (!text) {
-			return "ask"
+			return { decision: "ask" }
 		}
 
 		if (state.alwaysAllowExecute === true) {
 			const decision = getCommandDecision(text, state.allowedCommands || [], state.deniedCommands || [])
 
 			if (decision === "auto_approve") {
-				return "approve"
+				return { decision: "approve" }
 			} else if (decision === "auto_deny") {
-				return "deny"
+				return { decision: "deny" }
 			} else {
-				return "ask"
+				return { decision: "ask" }
 			}
 		}
 	}
@@ -110,50 +140,50 @@ export async function checkAutoApproval({
 		}
 
 		if (!tool) {
-			return "ask"
+			return { decision: "ask" }
 		}
 
 		if (tool.tool === "updateTodoList") {
-			return state.alwaysAllowUpdateTodoList === true ? "approve" : "ask"
+			return state.alwaysAllowUpdateTodoList === true ? { decision: "approve" } : { decision: "ask" }
 		}
 
 		if (tool?.tool === "fetchInstructions") {
 			if (tool.content === "create_mode") {
-				return state.alwaysAllowModeSwitch === true ? "approve" : "ask"
+				return state.alwaysAllowModeSwitch === true ? { decision: "approve" } : { decision: "ask" }
 			}
 
 			if (tool.content === "create_mcp_server") {
-				return state.alwaysAllowMcp === true ? "approve" : "ask"
+				return state.alwaysAllowMcp === true ? { decision: "approve" } : { decision: "ask" }
 			}
 		}
 
 		if (tool?.tool === "switchMode") {
-			return state.alwaysAllowModeSwitch === true ? "approve" : "ask"
+			return state.alwaysAllowModeSwitch === true ? { decision: "approve" } : { decision: "ask" }
 		}
 
 		if (["newTask", "finishTask"].includes(tool?.tool)) {
-			return state.alwaysAllowSubtasks === true ? "approve" : "ask"
+			return state.alwaysAllowSubtasks === true ? { decision: "approve" } : { decision: "ask" }
 		}
 
 		const isOutsideWorkspace = !!tool.isOutsideWorkspace
 
 		if (isReadOnlyToolAction(tool)) {
 			return state.alwaysAllowReadOnly === true &&
 				(!isOutsideWorkspace || state.alwaysAllowReadOnlyOutsideWorkspace === true)
-				? "approve"
-				: "ask"
+				? { decision: "approve" }
+				: { decision: "ask" }
 		}
 
 		if (isWriteToolAction(tool)) {
 			return state.alwaysAllowWrite === true &&
 				(!isOutsideWorkspace || state.alwaysAllowWriteOutsideWorkspace === true) &&
 				(!isProtected || state.alwaysAllowWriteProtected === true)
-				? "approve"
-				: "ask"
+				? { decision: "approve" }
+				: { decision: "ask" }
 		}
 	}
 
-	return "ask"
+	return { decision: "ask" }
 }
 
 export { AutoApprovalHandler } from "./AutoApprovalHandler"

src/core/task/Task.ts

@@ -823,46 +823,55 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 			await this.addToClineMessages({ ts: askTs, type: "ask", ask: type, text, isProtected })
 		}
 
+		let timeouts: NodeJS.Timeout[] = []
+
 		// Automatically approve if the ask according to the user's settings.
 		const provider = this.providerRef.deref()
 		const state = provider ? await provider.getState() : undefined
-		const approval = state ? await checkAutoApproval({ state, ask: type, text, isProtected }) : false
+		const approval = await checkAutoApproval({ state, ask: type, text, isProtected })
 
-		if (approval === "approve") {
+		if (approval.decision === "approve") {
 			this.approveAsk()
-		} else if (approval === "deny") {
+		} else if (approval.decision === "deny") {
 			this.denyAsk()
+		} else if (approval.decision === "timeout") {
+			timeouts.push(
+				setTimeout(() => {
+					const { askResponse, text, images } = approval.fn()
+					this.handleWebviewAskResponse(askResponse, text, images)
+				}, approval.timeout),
+			)
 		}
 
 		// The state is mutable if the message is complete and the task will
 		// block (via the `pWaitFor`).
 		const isBlocking = !(this.askResponse !== undefined || this.lastMessageTs !== askTs)
 		const isMessageQueued = !this.messageQueueService.isEmpty()
 
-		const isStatusMutable = !partial && isBlocking && !isMessageQueued && approval === "ask"
-		let statusMutationTimeouts: NodeJS.Timeout[] = []
-		const statusMutationTimeout = 5_000
+		const isStatusMutable = !partial && isBlocking && !isMessageQueued && approval.decision === "ask"
 
 		if (isBlocking) {
 			console.log(`Task#ask will block -> type: ${type}`)
 		}
 
 		if (isStatusMutable) {
 			console.log(`Task#ask: status is mutable -> type: ${type}`)
+			const statusMutationTimeout = 2_000
 
 			if (isInteractiveAsk(type)) {
-				statusMutationTimeouts.push(
+				timeouts.push(
 					setTimeout(() => {
 						const message = this.findMessageByTimestamp(askTs)
 
 						if (message) {
 							this.interactiveAsk = message
 							this.emit(RooCodeEventName.TaskInteractive, this.taskId)
+							provider?.postMessageToWebview({ type: "interactionRequired" })
 						}
 					}, statusMutationTimeout),
 				)
 			} else if (isResumableAsk(type)) {
-				statusMutationTimeouts.push(
+				timeouts.push(
 					setTimeout(() => {
 						const message = this.findMessageByTimestamp(askTs)
 
@@ -873,7 +882,7 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 					}, statusMutationTimeout),
 				)
 			} else if (isIdleAsk(type)) {
-				statusMutationTimeouts.push(
+				timeouts.push(
 					setTimeout(() => {
 						const message = this.findMessageByTimestamp(askTs)
 
@@ -925,7 +934,7 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 		this.askResponseImages = undefined
 
 		// Cancel the timeouts if they are still running.
-		statusMutationTimeouts.forEach((timeout) => clearTimeout(timeout))
+		timeouts.forEach((timeout) => clearTimeout(timeout))
 
 		// Switch back to an active state.
 		if (this.idleAsk || this.resumableAsk || this.interactiveAsk) {

src/shared/ExtensionMessage.ts

@@ -127,6 +127,7 @@ export interface ExtensionMessage {
 		| "insertTextIntoTextarea"
 		| "dismissedUpsells"
 		| "organizationSwitchResult"
+		| "interactionRequired"
 	text?: string
 	payload?: any // Add a generic payload for now, can refine later
 	// Checkpoint warning message