fix(extension): preserve headless tool approval checks

Author: edelauna

apps/vscode-e2e/src/suite/tools/use-mcp-tool.test.ts

@@ -64,10 +64,9 @@ suite("Roo Code use_mcp_tool Tool", function () {
 				{
 					mcpServers: {
 						[FILESYSTEM_SERVER_NAME]: {
-							command: process.execPath,
+							command: process.env.npm_node_execpath ?? "node",
 							args: [path.join(__dirname, "fixtures", "filesystem-mcp-server.js"), workspaceDir],
 							env: {
-								ELECTRON_RUN_AS_NODE: "1",
 								MCP_TEST_READY_FILE: mcpServerReadyPath,
 							},
 							alwaysAllow: [

src/extension/__tests__/api.spec.ts

@@ -1,8 +1,10 @@
 import type * as vscode from "vscode"
-import { IpcMessageType, TaskCommandName, type IpcMessage } from "@roo-code/types"
+import { IpcMessageType, TaskCommandName, type ClineMessage, type IpcMessage } from "@roo-code/types"
 
 import { API } from "../api"
 import type { ClineProvider } from "../../core/webview/ClineProvider"
+import { MessageQueueService } from "../../core/message-queue/MessageQueueService"
+import { Task } from "../../core/task/Task"
 
 vi.mock("vscode")
 vi.mock("../../core/webview/ClineProvider")
@@ -14,6 +16,33 @@ type TaskCommandHandler = (
 
 let taskCommandHandler: TaskCommandHandler | undefined
 
+type TaskTestAccess = {
+	addToClineMessages: (message: ClineMessage) => Promise<void>
+}
+
+const createStreamingTask = (provider: object) => {
+	const task = Object.create(Task.prototype) as Task
+	Object.assign(task, {
+		abort: false,
+		clineMessages: [],
+		taskId: "task-1",
+		instanceId: "instance-1",
+		isStreaming: true,
+		messageQueueService: new MessageQueueService(),
+		providerRef: { deref: () => provider },
+		addToClineMessages: vi.fn(async () => {}),
+		saveClineMessages: vi.fn(async () => true),
+		updateClineMessage: vi.fn(async () => {}),
+		cancelAutoApprovalTimeout: vi.fn(),
+		checkpointSave: vi.fn(async () => {}),
+		emit: vi.fn(),
+	})
+	vi.spyOn(task as unknown as TaskTestAccess, "addToClineMessages").mockImplementation(async (message) => {
+		task.clineMessages.push(message)
+	})
+	return task
+}
+
 vi.mock("@roo-code/ipc", () => ({
 	IpcServer: class {
 		listen() {}
@@ -26,10 +55,11 @@ vi.mock("@roo-code/ipc", () => ({
 }))
 
 describe("API.sendMessage", () => {
-	it("enqueues directly when the current task is streaming", async () => {
+	it("enqueues directly when the current webview task is streaming", async () => {
 		const addMessage = vi.fn()
 		const postMessageToWebview = vi.fn()
 		const provider = {
+			viewLaunched: true,
 			getCurrentTask: vi.fn().mockReturnValue({
 				isStreaming: true,
 				messageQueueService: { addMessage },
@@ -51,29 +81,41 @@ describe("API.sendMessage", () => {
 		expect(addMessage).toHaveBeenCalledWith("", images)
 	})
 
-	it("delivers SendMessage commands through the IPC handler", async () => {
-		const addMessage = vi.fn()
+	it.each([
+		["command", "npm publish"],
+		["use_mcp_server", '{"server_name":"filesystem","tool_name":"write_file"}'],
+	] as const)("does not approve a protected headless %s ask from queued IPC input", async (askType, askText) => {
 		const appendLine = vi.fn()
 		const provider = {
 			context: {},
 			cwd: "/test/cwd",
-			getCurrentTask: vi.fn().mockReturnValue({
-				isStreaming: true,
-				messageQueueService: { addMessage },
-			}),
+			viewLaunched: false,
+			getState: vi.fn().mockResolvedValue({ autoApprovalEnabled: false }),
+			getCurrentTask: vi.fn(),
 			getCurrentTaskStack: vi.fn().mockReturnValue([]),
 			on: vi.fn(),
 		} as unknown as ClineProvider
+		const task = createStreamingTask(provider)
+		vi.mocked(provider.getCurrentTask).mockReturnValue(task)
 		new API({ appendLine } as unknown as vscode.OutputChannel, provider, "/tmp/roo-test.sock", true)
 		const images = ["data:image/png;base64,image1data"]
+		const executeProtectedTool = vi.fn()
+		const ask = task.ask(askType, askText, false)
+		await vi.waitFor(() => expect(task.clineMessages).toHaveLength(1))
 
 		await taskCommandHandler?.("client-1", {
 			commandName: TaskCommandName.SendMessage,
 			data: { text: "Use this before completing", images },
 		})
+		const result = await ask
+		if (result.response === "yesButtonClicked") {
+			executeProtectedTool()
+		}
 
 		expect(appendLine).toHaveBeenCalledWith("[API] SendMessage -> Use this before completing")
-		expect(addMessage).toHaveBeenCalledWith("Use this before completing", images)
+		expect(result).toMatchObject({ response: "messageResponse", text: "Use this before completing", images })
+		expect(task.messageQueueService.isEmpty()).toBe(true)
+		expect(executeProtectedTool).not.toHaveBeenCalled()
 	})
 
 	it("logs rejected SendMessage commands without rejecting the IPC handler", async () => {

src/extension/api.ts

@@ -328,15 +328,9 @@ export class API extends EventEmitter<RooCodeEvents> implements RooCodeAPI {
 	public async sendMessage(text?: string, images?: string[]) {
 		const currentTask = this.sidebarProvider.getCurrentTask()
 
-		// Ensure steering input reaches the active task before it can finish.
-		if (currentTask?.isStreaming) {
-			currentTask.messageQueueService.addMessage(text ?? "", images)
-			return
-		}
-
 		// In headless/sandbox flows the webview may not be launched, so routing
-		// through invoke=sendMessage drops the message. Deliver directly to the
-		// task ask-response channel instead.
+		// through invoke=sendMessage drops the message. Keep this path on the task
+		// ask-response channel so queued input cannot approve protected tool asks.
 		if (!this.sidebarProvider.viewLaunched) {
 			if (!currentTask) {
 				this.log("[API#sendMessage] no current task in headless mode; message dropped")
@@ -347,6 +341,12 @@ export class API extends EventEmitter<RooCodeEvents> implements RooCodeAPI {
 			return
 		}
 
+		// Ensure steering input reaches the active task before it can finish.
+		if (currentTask?.isStreaming) {
+			currentTask.messageQueueService.addMessage(text ?? "", images)
+			return
+		}
+
 		await this.sidebarProvider.postMessageToWebview({ type: "invoke", invoke: "sendMessage", text, images })
 	}