Merge branch 'RooVetGit:main' into human-relay

Author: NyxJae

.github/workflows/marketplace-publish.yml

@@ -27,8 +27,8 @@ jobs:
           node-version: 18
 
       - run: |
-          git config user.name github-actions
-          git config user.email github-actions@github.com
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
 
       - name: Install Dependencies
         run: |

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Roo Code Changelog
 
+## [3.8.6] - 2025-03-13
+
+- Revert SSE MCP support while we debug some config validation issues
+
 ## [3.8.5] - 2025-03-12
 
 - Refactor terminal architecture to address critical issues with the current design (thanks @KJ7LNW!)

e2e/src/suite/extension.test.ts

@@ -9,10 +9,6 @@ suite("Roo Code Extension", () => {
 	})
 
 	test("Commands should be registered", async () => {
-		const timeout = 10 * 1_000
-		const interval = 1_000
-		const startTime = Date.now()
-
 		const expectedCommands = [
 			"roo-cline.plusButtonClicked",
 			"roo-cline.mcpButtonClicked",
@@ -25,23 +21,6 @@ suite("Roo Code Extension", () => {
 			"roo-cline.improveCode",
 		]
 
-		while (Date.now() - startTime < timeout) {
-			const commands = await vscode.commands.getCommands(true)
-			const missingCommands = []
-
-			for (const cmd of expectedCommands) {
-				if (!commands.includes(cmd)) {
-					missingCommands.push(cmd)
-				}
-			}
-
-			if (missingCommands.length === 0) {
-				break
-			}
-
-			await new Promise((resolve) => setTimeout(resolve, interval))
-		}
-
 		const commands = await vscode.commands.getCommands(true)
 
 		for (const cmd of expectedCommands) {

e2e/src/suite/index.ts

@@ -8,55 +8,39 @@ import { RooCodeAPI } from "../../../src/exports/roo-code"
 import { waitUntilReady } from "./utils"
 
 declare global {
-	var extension: vscode.Extension<RooCodeAPI> | undefined
 	var api: RooCodeAPI
 }
 
 export async function run() {
-	const mocha = new Mocha({ ui: "tdd", timeout: 300_000 })
-	const testsRoot = path.resolve(__dirname, "..")
-
-	try {
-		// Find all test files.
-		const files = await glob("**/**.test.js", { cwd: testsRoot })
-		files.forEach((f: string) => mocha.addFile(path.resolve(testsRoot, f)))
-
-		const extension = vscode.extensions.getExtension<RooCodeAPI>("RooVeterinaryInc.roo-cline")
-
-		if (!extension) {
-			throw new Error("Extension not found")
-		}
-
-		const api = extension.isActive ? extension.exports : await extension.activate()
-
-		await api.setConfiguration({
-			apiProvider: "openrouter",
-			openRouterApiKey: process.env.OPENROUTER_API_KEY!,
-			openRouterModelId: "anthropic/claude-3.5-sonnet",
-		})
-
-		await waitUntilReady(api)
-
-		globalThis.api = api
-		globalThis.extension = extension
-
-		return new Promise<void>((resolve, reject) => {
-			try {
-				mocha.run((failures: number) => {
-					if (failures > 0) {
-						reject(new Error(`${failures} tests failed.`))
-					} else {
-						resolve()
-					}
-				})
-			} catch (err) {
-				console.error(err)
-				reject(err)
-			}
-		})
-	} catch (err) {
-		console.error("Error while running tests:")
-		console.error(err)
-		throw err
+	const extension = vscode.extensions.getExtension<RooCodeAPI>("RooVeterinaryInc.roo-cline")
+
+	if (!extension) {
+		throw new Error("Extension not found")
 	}
+
+	// Activate the extension if it's not already active.
+	const api = extension.isActive ? extension.exports : await extension.activate()
+
+	// TODO: We might want to support a "free" model out of the box so
+	// contributors can run the tests locally without having to pay.
+	await api.setConfiguration({
+		apiProvider: "openrouter",
+		openRouterApiKey: process.env.OPENROUTER_API_KEY!,
+		openRouterModelId: "anthropic/claude-3.5-sonnet",
+	})
+
+	await waitUntilReady({ api })
+
+	// Expose the API to the tests.
+	globalThis.api = api
+
+	// Add all the tests to the runner.
+	const mocha = new Mocha({ ui: "tdd", timeout: 300_000 })
+	const cwd = path.resolve(__dirname, "..")
+	;(await glob("**/**.test.js", { cwd })).forEach((testFile) => mocha.addFile(path.resolve(cwd, testFile)))
+
+	// Let's go!
+	return new Promise<void>((resolve, reject) =>
+		mocha.run((failures) => (failures === 0 ? resolve() : reject(new Error(`${failures} tests failed.`)))),
+	)
 }

e2e/src/suite/modes.test.ts

@@ -1,63 +1,44 @@
 import * as assert from "assert"
 
-import { waitForMessage } from "./utils"
+import { getCompletion, getMessage, sleep, waitForCompletion, waitUntilAborted } from "./utils"
 
 suite("Roo Code Modes", () => {
 	test("Should handle switching modes correctly", async function () {
-		const timeout = 300_000
 		const api = globalThis.api
 
-		const testPrompt =
-			"For each mode (Code, Architect, Ask) respond with the mode name and what it specializes in after switching to that mode, do not start with the current mode, be sure to say 'I AM DONE' after the task is complete."
+		/**
+		 * Switch modes.
+		 */
 
-		await api.setConfiguration({ mode: "Code", alwaysAllowModeSwitch: true, autoApprovalEnabled: true })
-		await api.startNewTask(testPrompt)
+		const switchModesPrompt =
+			"For each mode (Code, Architect, Ask) respond with the mode name and what it specializes in after switching to that mode. " +
+			"Do not start with the current mode."
 
-		await waitForMessage(api, { include: "I AM DONE", exclude: "be sure to say", timeout })
+		await api.setConfiguration({ mode: "Code", alwaysAllowModeSwitch: true, autoApprovalEnabled: true })
+		const switchModesTaskId = await api.startNewTask(switchModesPrompt)
+		await waitForCompletion({ api, taskId: switchModesTaskId, timeout: 60_000 })
 
-		if (api.getMessages().length === 0) {
-			assert.fail("No messages received")
-		}
+		/**
+		 * Grade the response.
+		 */
 
-		// Log the messages to the console.
-		api.getMessages().forEach(({ type, text }) => {
-			if (type === "say") {
-				console.log(text)
-			}
-		})
+		const gradePrompt =
+			`Given this prompt: ${switchModesPrompt} grade the response from 1 to 10 in the format of "Grade: (1-10)": ` +
+			api
+				.getMessages(switchModesTaskId)
+				.filter(({ type }) => type === "say")
+				.map(({ text }) => text ?? "")
+				.join("\n")
 
-		// Start Grading Portion of test to grade the response from 1 to 10.
 		await api.setConfiguration({ mode: "Ask" })
+		const gradeTaskId = await api.startNewTask(gradePrompt)
+		await waitForCompletion({ api, taskId: gradeTaskId, timeout: 60_000 })
 
-		let output = api
-			.getMessages()
-			.map(({ type, text }) => (type === "say" ? text : ""))
-			.join("\n")
-
-		await api.startNewTask(
-			`Given this prompt: ${testPrompt} grade the response from 1 to 10 in the format of "Grade: (1-10)": ${output}\nBe sure to say 'I AM DONE GRADING' after the task is complete.`,
-		)
-
-		await waitForMessage(api, { include: "I AM DONE GRADING", exclude: "be sure to say", timeout })
-
-		if (api.getMessages().length === 0) {
-			assert.fail("No messages received")
-		}
-
-		api.getMessages().forEach(({ type, text }) => {
-			if (type === "say" && text?.includes("Grade:")) {
-				console.log(text)
-			}
-		})
-
-		const gradeMessage = api
-			.getMessages()
-			.find(
-				({ type, text }) => type === "say" && !text?.includes("Grade: (1-10)") && text?.includes("Grade:"),
-			)?.text
+		const completion = getCompletion({ api, taskId: gradeTaskId })
+		const match = completion?.text?.match(/Grade: (\d+)/)
+		const score = parseInt(match?.[1] ?? "0")
+		assert.ok(score >= 7 && score <= 10, `Grade must be between 7 and 10 - ${completion?.text}`)
 
-		const gradeMatch = gradeMessage?.match(/Grade: (\d+)/)
-		const gradeNum = gradeMatch ? parseInt(gradeMatch[1]) : undefined
-		assert.ok(gradeNum !== undefined && gradeNum >= 7 && gradeNum <= 10, "Grade must be between 7 and 10")
+		await api.cancelCurrentTask()
 	})
 })

e2e/src/suite/subtasks.test.ts

@@ -1,58 +1,71 @@
 import * as assert from "assert"
 
-import { sleep, waitForToolUse, waitForMessage } from "./utils"
+import { sleep, waitFor, getMessage, waitForCompletion } from "./utils"
 
 suite("Roo Code Subtasks", () => {
-	test.skip("Should handle subtask cancellation and resumption correctly", async function () {
+	test("Should handle subtask cancellation and resumption correctly", async function () {
 		const api = globalThis.api
 
 		await api.setConfiguration({
 			mode: "Code",
 			alwaysAllowModeSwitch: true,
 			alwaysAllowSubtasks: true,
 			autoApprovalEnabled: true,
+			enableCheckpoints: false,
 		})
 
+		const childPrompt = "You are a calculator. Respond only with numbers. What is the square root of 9?"
+
 		// Start a parent task that will create a subtask.
-		await api.startNewTask(
+		const parentTaskId = await api.startNewTask(
 			"You are the parent task. " +
-				"Create a subtask by using the new_task tool with the message 'You are the subtask'. " +
-				"After creating the subtask, wait for it to complete and then respond with 'Parent task resumed'.",
+				`Create a subtask by using the new_task tool with the message '${childPrompt}'.` +
+				"After creating the subtask, wait for it to complete and then respond 'Parent task resumed'.",
 		)
 
-		await waitForToolUse(api, "new_task")
+		let spawnedTaskId: string | undefined = undefined
 
-		// Cancel the current task (which should be the subtask).
-		await api.cancelTask()
+		// Wait for the subtask to be spawned and then cancel it.
+		api.on("taskSpawned", (_, childTaskId) => (spawnedTaskId = childTaskId))
+		await waitFor(() => !!spawnedTaskId)
+		await sleep(2_000) // Give the task a chance to start and populate the history.
+		await api.cancelCurrentTask()
 
-		// Check if the parent task is still waiting (not resumed). We need to
-		// wait a bit to ensure any task resumption would have happened.
-		await sleep(5_000)
+		// Wait a bit to ensure any task resumption would have happened.
+		await sleep(2_000)
 
 		// The parent task should not have resumed yet, so we shouldn't see
 		// "Parent task resumed".
 		assert.ok(
-			!api.getMessages().some(({ type, text }) => type === "say" && text?.includes("Parent task resumed")),
-			"Parent task should not have resumed after subtask cancellation.",
+			getMessage({
+				api,
+				taskId: parentTaskId,
+				include: "Parent task resumed",
+				exclude: "You are the parent task",
+			}) === undefined,
+			"Parent task should not have resumed after subtask cancellation",
 		)
 
 		// Start a new task with the same message as the subtask.
-		await api.startNewTask("You are the subtask")
-
-		// Wait for the subtask to complete.
-		await waitForMessage(api, { include: "Task complete" })
+		const anotherTaskId = await api.startNewTask(childPrompt)
+		await waitForCompletion({ api, taskId: anotherTaskId })
 
-		// Verify that the parent task is still not resumed. We need to wait a
-		// bit to ensure any task resumption would have happened.
-		await sleep(5_000)
+		// Wait a bit to ensure any task resumption would have happened.
+		await sleep(2_000)
 
 		// The parent task should still not have resumed.
 		assert.ok(
-			!api.getMessages().some(({ type, text }) => type === "say" && text?.includes("Parent task resumed")),
-			"Parent task should not have resumed after subtask completion.",
+			getMessage({
+				api,
+				taskId: parentTaskId,
+				include: "Parent task resumed",
+				exclude: "You are the parent task",
+			}) === undefined,
+			"Parent task should not have resumed after subtask cancellation",
 		)
 
 		// Clean up - cancel all tasks.
-		await api.cancelTask()
+		await api.clearCurrentTask()
+		await waitForCompletion({ api, taskId: parentTaskId })
 	})
 })

e2e/src/suite/task.test.ts

@@ -4,7 +4,7 @@ suite("Roo Code Task", () => {
 	test("Should handle prompt and response correctly", async function () {
 		const api = globalThis.api
 		await api.setConfiguration({ mode: "Ask", alwaysAllowModeSwitch: true, autoApprovalEnabled: true })
-		await api.startNewTask("Hello world, what is your name? Respond with 'My name is ...'")
-		await waitForMessage(api, { include: "My name is Roo" })
+		const taskId = await api.startNewTask("Hello world, what is your name? Respond with 'My name is ...'")
+		await waitForMessage({ api, taskId, include: "My name is Roo" })
 	})
 })