Allow processes to access the Roo Code API via a unix socket (#2232)

Author: cte

.tool-versions

@@ -0,0 +1 @@
+nodejs v20.18.1

e2e/VSCODE_INTEGRATION_TESTS.md

@@ -156,7 +156,7 @@ while (Date.now() - startTime < timeout) {
 6. **Grading**: When grading tests, use the `Grade:` format to ensure the test is graded correctly (See modes.test.ts for an example).
 
 ```typescript
-await globalThis.api.startNewTask(
-	`Given this prompt: ${testPrompt} grade the response from 1 to 10 in the format of "Grade: (1-10)": ${output} \n Be sure to say 'I AM DONE GRADING' after the task is complete`,
-)
+await globalThis.api.startNewTask({
+	text: `Given this prompt: ${testPrompt} grade the response from 1 to 10 in the format of "Grade: (1-10)": ${output} \n Be sure to say 'I AM DONE GRADING' after the task is complete`,
+})
 ```

e2e/package.json

@@ -3,13 +3,12 @@
 	"version": "0.1.0",
 	"private": true,
 	"scripts": {
-		"build": "cd .. && npm run compile && npm run build:webview",
-		"compile": "rm -rf out && tsc -p tsconfig.json",
 		"lint": "eslint src --ext ts",
 		"check-types": "tsc --noEmit",
-		"test": "npm run compile && npx dotenvx run -f .env.local -- node ./out/runTest.js",
-		"ci": "npm run build && npm run test",
-		"clean": "rimraf out"
+		"test": "npm run build && npx dotenvx run -f .env.local -- node ./out/runTest.js",
+		"ci": "npm run vscode-test && npm run test",
+		"build": "rimraf out && tsc -p tsconfig.json",
+		"vscode-test": "cd .. && npm run vscode-test"
 	},
 	"dependencies": {},
 	"devDependencies": {

e2e/src/suite/extension.test.ts

@@ -2,12 +2,6 @@ import * as assert from "assert"
 import * as vscode from "vscode"
 
 suite("Roo Code Extension", () => {
-	test("OPENROUTER_API_KEY environment variable is set", () => {
-		if (!process.env.OPENROUTER_API_KEY) {
-			assert.fail("OPENROUTER_API_KEY environment variable is not set")
-		}
-	})
-
 	test("Commands should be registered", async () => {
 		const expectedCommands = [
 			"roo-cline.plusButtonClicked",

e2e/src/suite/index.ts

@@ -3,9 +3,9 @@ import Mocha from "mocha"
 import { glob } from "glob"
 import * as vscode from "vscode"
 
-import { RooCodeAPI } from "../../../src/exports/roo-code"
+import type { RooCodeAPI } from "../../../src/exports/roo-code"
 
-import { waitUntilReady } from "./utils"
+import { waitFor } from "./utils"
 
 declare global {
 	var api: RooCodeAPI
@@ -18,18 +18,25 @@ export async function run() {
 		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",
+		apiProvider: "openrouter" as const,
 		openRouterApiKey: process.env.OPENROUTER_API_KEY!,
-		openRouterModelId: "anthropic/claude-3.5-sonnet",
+		openRouterModelId: "google/gemini-2.0-flash-001",
+		openRouterModelInfo: {
+			maxTokens: 8192,
+			contextWindow: 1000000,
+			supportsImages: true,
+			supportsPromptCache: false,
+			inputPrice: 0.1,
+			outputPrice: 0.4,
+			thinking: false,
+		},
 	})
 
-	await waitUntilReady({ api })
+	await vscode.commands.executeCommand("roo-cline.SidebarProvider.focus")
+	await waitFor(() => api.isReady())
 
 	// Expose the API to the tests.
 	globalThis.api = api

e2e/src/suite/modes.test.ts

@@ -1,9 +1,11 @@
 import * as assert from "assert"
 
-import { getCompletion, getMessage, sleep, waitForCompletion, waitUntilAborted } from "./utils"
+import type { ClineMessage } from "../../../src/exports/roo-code"
+
+import { waitUntilCompleted } from "./utils"
 
 suite("Roo Code Modes", () => {
-	test("Should handle switching modes correctly", async function () {
+	test("Should handle switching modes correctly", async () => {
 		const api = globalThis.api
 
 		/**
@@ -14,30 +16,44 @@ suite("Roo Code Modes", () => {
 			"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 api.setConfiguration({ mode: "Code", alwaysAllowModeSwitch: true, autoApprovalEnabled: true })
-		const switchModesTaskId = await api.startNewTask(switchModesPrompt)
-		await waitForCompletion({ api, taskId: switchModesTaskId, timeout: 60_000 })
+		let messages: ClineMessage[] = []
+
+		api.on("message", ({ message }) => {
+			if (message.type === "say" && message.partial === false) {
+				messages.push(message)
+			}
+		})
+
+		const switchModesTaskId = await api.startNewTask({
+			configuration: { mode: "Code", alwaysAllowModeSwitch: true, autoApprovalEnabled: true },
+			text: switchModesPrompt,
+		})
+
+		await waitUntilCompleted({ api, taskId: switchModesTaskId, timeout: 60_000 })
 
 		/**
 		 * Grade the response.
 		 */
 
-		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")
+		const response = messages
+			.filter(({ type, say, partial }) => say === "text")
+			.map(({ text }) => text ?? "")
+			.join("\n")
+
+		const gradePrompt = `Given this prompt: ${switchModesPrompt} grade the response from 1 to 10 in the format of "Grade: (1-10)". For example: Grade 7\n\nResponse: ${response}`
+
+		messages = []
 
-		await api.setConfiguration({ mode: "Ask" })
-		const gradeTaskId = await api.startNewTask(gradePrompt)
-		await waitForCompletion({ api, taskId: gradeTaskId, timeout: 60_000 })
+		const gradeTaskId = await api.startNewTask({ configuration: { mode: "Ask" }, text: gradePrompt })
+		await waitUntilCompleted({ api, taskId: gradeTaskId })
 
-		const completion = getCompletion({ api, taskId: gradeTaskId })
+		const completion = messages.find(({ type, say, partial }) => say === "completion_result")
 		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}`)
+		assert.ok(
+			score >= 7 && score <= 10,
+			`Grade must be between 7 and 10. DEBUG: score = ${score}, completion = ${completion?.text}`,
+		)
 
 		await api.cancelCurrentTask()
 	})

e2e/src/suite/subtasks.test.ts

@@ -1,13 +1,24 @@
 import * as assert from "assert"
 
-import { sleep, waitFor, getMessage, waitForCompletion } from "./utils"
+import type { ClineMessage } from "../../../src/exports/roo-code"
+
+import { sleep, waitFor, waitUntilCompleted } from "./utils"
 
 suite("Roo Code Subtasks", () => {
-	test("Should handle subtask cancellation and resumption correctly", async function () {
+	test("Should handle subtask cancellation and resumption correctly", async () => {
 		const api = globalThis.api
 
+		const messages: Record<string, ClineMessage[]> = {}
+
+		api.on("message", ({ taskId, message }) => {
+			if (message.type === "say" && message.partial === false) {
+				messages[taskId] = messages[taskId] || []
+				messages[taskId].push(message)
+			}
+		})
+
 		await api.setConfiguration({
-			mode: "Code",
+			mode: "ask",
 			alwaysAllowModeSwitch: true,
 			alwaysAllowSubtasks: true,
 			autoApprovalEnabled: true,
@@ -17,18 +28,19 @@ suite("Roo Code Subtasks", () => {
 		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.
-		const parentTaskId = await api.startNewTask(
-			"You are the parent task. " +
+		const parentTaskId = await api.startNewTask({
+			text:
+				"You are the parent task. " +
 				`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'.",
-		)
+		})
 
 		let spawnedTaskId: string | undefined = undefined
 
 		// 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 sleep(1_000) // Give the task a chance to start and populate the history.
 		await api.cancelCurrentTask()
 
 		// Wait a bit to ensure any task resumption would have happened.
@@ -37,35 +49,27 @@ suite("Roo Code Subtasks", () => {
 		// The parent task should not have resumed yet, so we shouldn't see
 		// "Parent task resumed".
 		assert.ok(
-			getMessage({
-				api,
-				taskId: parentTaskId,
-				include: "Parent task resumed",
-				exclude: "You are the parent task",
-			}) === undefined,
+			messages[parentTaskId].find(({ type, text }) => type === "say" && text === "Parent task resumed") ===
+				undefined,
 			"Parent task should not have resumed after subtask cancellation",
 		)
 
 		// Start a new task with the same message as the subtask.
-		const anotherTaskId = await api.startNewTask(childPrompt)
-		await waitForCompletion({ api, taskId: anotherTaskId })
+		const anotherTaskId = await api.startNewTask({ text: childPrompt })
+		await waitUntilCompleted({ api, taskId: anotherTaskId })
 
 		// 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(
-			getMessage({
-				api,
-				taskId: parentTaskId,
-				include: "Parent task resumed",
-				exclude: "You are the parent task",
-			}) === undefined,
+			messages[parentTaskId].find(({ type, text }) => type === "say" && text === "Parent task resumed") ===
+				undefined,
 			"Parent task should not have resumed after subtask cancellation",
 		)
 
 		// Clean up - cancel all tasks.
 		await api.clearCurrentTask()
-		await waitForCompletion({ api, taskId: parentTaskId })
+		await waitUntilCompleted({ api, taskId: parentTaskId })
 	})
 })

e2e/src/suite/task.test.ts

@@ -1,10 +1,33 @@
-import { waitForMessage } from "./utils"
+import * as assert from "assert"
+
+import type { ClineMessage } from "../../../src/exports/roo-code"
+
+import { waitUntilCompleted } from "./utils"
 
 suite("Roo Code Task", () => {
-	test("Should handle prompt and response correctly", async function () {
+	test("Should handle prompt and response correctly", async () => {
 		const api = globalThis.api
-		await api.setConfiguration({ mode: "Ask", alwaysAllowModeSwitch: true, autoApprovalEnabled: true })
-		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" })
+
+		const messages: ClineMessage[] = []
+
+		api.on("message", ({ message }) => {
+			if (message.type === "say" && message.partial === false) {
+				messages.push(message)
+			}
+		})
+
+		const taskId = await api.startNewTask({
+			configuration: { mode: "Ask", alwaysAllowModeSwitch: true, autoApprovalEnabled: true },
+			text: "Hello world, what is your name? Respond with 'My name is ...'",
+		})
+
+		await waitUntilCompleted({ api, taskId })
+
+		const completion = messages.find(({ say, partial }) => say === "completion_result")
+
+		assert.ok(
+			completion?.text?.includes("My name is Roo"),
+			`Completion should include "My name is Roo" - ${completion?.text}`,
+		)
 	})
 })

e2e/src/suite/utils.ts

@@ -1,6 +1,6 @@
 import * as vscode from "vscode"
 
-import { RooCodeAPI } from "../../../src/exports/roo-code"
+import type { RooCodeAPI } from "../../../src/exports/roo-code"
 
 type WaitForOptions = {
 	timeout?: number
@@ -9,7 +9,7 @@ type WaitForOptions = {
 
 export const waitFor = (
 	condition: (() => Promise<boolean>) | (() => boolean),
-	{ timeout = 60_000, interval = 250 }: WaitForOptions = {},
+	{ timeout = 30_000, interval = 250 }: WaitForOptions = {},
 ) => {
 	let timeoutId: NodeJS.Timeout | undefined = undefined
 
@@ -41,15 +41,6 @@ export const waitFor = (
 	])
 }
 
-type WaitUntilReadyOptions = WaitForOptions & {
-	api: RooCodeAPI
-}
-
-export const waitUntilReady = async ({ api, ...options }: WaitUntilReadyOptions) => {
-	await vscode.commands.executeCommand("roo-cline.SidebarProvider.focus")
-	await waitFor(() => api.isReady(), options)
-}
-
 type WaitUntilAbortedOptions = WaitForOptions & {
 	api: RooCodeAPI
 	taskId: string
@@ -61,39 +52,15 @@ export const waitUntilAborted = async ({ api, taskId, ...options }: WaitUntilAbo
 	await waitFor(() => set.has(taskId), options)
 }
 
-export const waitForCompletion = async ({
-	api,
-	taskId,
-	...options
-}: WaitUntilReadyOptions & {
-	taskId: string
-}) => waitFor(() => !!getCompletion({ api, taskId }), options)
-
-export const getCompletion = ({ api, taskId }: { api: RooCodeAPI; taskId: string }) =>
-	api.getMessages(taskId).find(({ say, partial }) => say === "completion_result" && partial === false)
-
-type WaitForMessageOptions = WaitUntilReadyOptions & {
-	taskId: string
-	include: string
-	exclude?: string
-}
-
-export const waitForMessage = async ({ api, taskId, include, exclude, ...options }: WaitForMessageOptions) =>
-	waitFor(() => !!getMessage({ api, taskId, include, exclude }), options)
-
-type GetMessageOptions = {
+type WaitUntilCompletedOptions = WaitForOptions & {
 	api: RooCodeAPI
 	taskId: string
-	include: string
-	exclude?: string
 }
 
-export const getMessage = ({ api, taskId, include, exclude }: GetMessageOptions) =>
-	api
-		.getMessages(taskId)
-		.find(
-			({ type, text }) =>
-				type === "say" && text && text.includes(include) && (!exclude || !text.includes(exclude)),
-		)
+export const waitUntilCompleted = async ({ api, taskId, ...options }: WaitUntilCompletedOptions) => {
+	const set = new Set<string>()
+	api.on("taskCompleted", (taskId) => set.add(taskId))
+	await waitFor(() => set.has(taskId), options)
+}
 
 export const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))

knip.json

@@ -17,6 +17,7 @@
 		"benchmark/**",
 		"src/activate/**",
 		"src/exports/**",
+		"src/schemas/ipc.ts",
 		"src/extension.ts",
 		"scripts/**"
 	],