Skip to content

Commit cf9437b

Browse files
committed
feat(api): add task control and global state APIs
1 parent f77fd55 commit cf9437b

4 files changed

Lines changed: 422 additions & 5 deletions

File tree

‎packages/types/src/api.ts‎

Lines changed: 16 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,7 @@ import type { EventEmitter } from "events"
22
import type { Socket } from "net"
33

44
import type { RooCodeEvents } from "./events.js"
5-
import type { RooCodeSettings } from "./global-settings.js"
5+
import type { GlobalState, RooCodeSettings } from "./global-settings.js"
66
import type { HistoryItem } from "./history.js"
77
import type { ProviderSettingsEntry, ProviderSettings } from "./provider-settings.js"
88
import type { IpcMessage, IpcServerEvents } from "./ipc.js"
@@ -21,11 +21,13 @@ export interface RooCodeAPI extends EventEmitter<RooCodeAPIEvents> {
2121
text,
2222
images,
2323
newTab,
24+
preserveOpenTabs,
2425
}: {
2526
configuration?: RooCodeSettings
2627
text?: string
2728
images?: string[]
2829
newTab?: boolean
30+
preserveOpenTabs?: boolean
2931
}): Promise<string>
3032
/**
3133
* Resumes a task with the given ID.
@@ -92,6 +94,15 @@ export interface RooCodeAPI extends EventEmitter<RooCodeAPIEvents> {
9294
* confirming a completion result. No-ops if no task is active.
9395
*/
9496
approveCurrentAsk(): Promise<void>
97+
/**
98+
* Programmatically approves the pending ask for a task by ID. Intended for use in tests only.
99+
*/
100+
approveTaskAsk(taskId: string): Promise<boolean>
101+
/**
102+
* Simulates selecting a follow-up suggestion for a task by ID, including its optional mode switch.
103+
* Intended for use in tests only.
104+
*/
105+
selectTaskFollowupSuggestion(options: { taskId: string; answer: string; mode?: string }): Promise<boolean>
95106
/**
96107
* Returns true if the API is ready to use.
97108
*/
@@ -106,6 +117,10 @@ export interface RooCodeAPI extends EventEmitter<RooCodeAPIEvents> {
106117
* @param values An object containing key-value pairs to set.
107118
*/
108119
setConfiguration(values: RooCodeSettings): Promise<void>
120+
/**
121+
* Returns a value from VS Code globalState. Intended for use in tests only.
122+
*/
123+
getGlobalState<K extends keyof GlobalState>(key: K): GlobalState[K]
109124
/**
110125
* Returns a list of all configured profile names
111126
* @returns Array of profile names
Lines changed: 73 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,73 @@
1+
import { EventEmitter } from "events"
2+
3+
import { describe, expect, it, vi, type Mock } from "vitest"
4+
import * as vscode from "vscode"
5+
6+
import { API } from "../api"
7+
import { ClineProvider } from "../../core/webview/ClineProvider"
8+
9+
vi.mock("@roo-code/ipc", () => ({
10+
IpcServer: class {},
11+
}))
12+
13+
vi.mock("../../integrations/terminal/Terminal", () => ({
14+
Terminal: {
15+
getTerminalProfile: vi.fn(),
16+
setTerminalProfile: vi.fn(),
17+
},
18+
}))
19+
20+
vi.mock("../../integrations/terminal/TerminalRegistry", () => ({
21+
TerminalRegistry: {
22+
closeIdleTerminals: vi.fn(),
23+
},
24+
}))
25+
26+
type ProviderDouble = EventEmitter & {
27+
context: vscode.ExtensionContext
28+
on: Mock<(...args: unknown[]) => unknown>
29+
setValues: Mock<(...args: unknown[]) => Promise<void>>
30+
contextProxy: {
31+
setValues: Mock<(...args: unknown[]) => Promise<void>>
32+
}
33+
providerSettingsManager: {
34+
saveConfig: Mock<(...args: unknown[]) => Promise<string>>
35+
}
36+
postStateToWebview: Mock<(...args: unknown[]) => Promise<void>>
37+
}
38+
39+
function asClineProvider(provider: ProviderDouble): ClineProvider {
40+
return provider as unknown as ClineProvider
41+
}
42+
43+
describe("API.setConfiguration", () => {
44+
it("routes configuration through ClineProvider.setValues so view-local state stays in sync", async () => {
45+
const outputChannel = { appendLine: vi.fn() } as unknown as vscode.OutputChannel
46+
const provider = {
47+
context: {} as vscode.ExtensionContext,
48+
on: vi.fn(),
49+
setValues: vi.fn().mockResolvedValue(undefined),
50+
contextProxy: {
51+
setValues: vi.fn().mockResolvedValue(undefined),
52+
},
53+
providerSettingsManager: {
54+
saveConfig: vi.fn().mockResolvedValue("default-id"),
55+
},
56+
postStateToWebview: vi.fn().mockResolvedValue(undefined),
57+
} as ProviderDouble
58+
const api = new API(outputChannel, asClineProvider(provider))
59+
const configuration = {
60+
apiProvider: "bedrock" as const,
61+
currentApiConfigName: "default",
62+
awsRegion: "us-east-1",
63+
apiModelId: "us.anthropic.claude-haiku-4-5-20251001-v1:0",
64+
}
65+
66+
await api.setConfiguration(configuration)
67+
68+
expect(provider.setValues).toHaveBeenCalledWith(configuration)
69+
expect(provider.contextProxy.setValues).not.toHaveBeenCalled()
70+
expect(provider.providerSettingsManager.saveConfig).toHaveBeenCalledWith("default", configuration)
71+
expect(provider.postStateToWebview).toHaveBeenCalled()
72+
})
73+
})
Lines changed: 263 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,263 @@
1+
import { EventEmitter } from "events"
2+
3+
import { describe, expect, it, vi, beforeEach, type Mock } from "vitest"
4+
import * as vscode from "vscode"
5+
6+
import { RooCodeEventName, type ModeConfig, type RooCodeSettings } from "@roo-code/types"
7+
8+
import { API } from "../api"
9+
import { ClineProvider } from "../../core/webview/ClineProvider"
10+
11+
const { openClineInNewTabMock } = vi.hoisted(() => ({
12+
openClineInNewTabMock: vi.fn(),
13+
}))
14+
15+
vi.mock("vscode", () => ({
16+
commands: {
17+
executeCommand: vi.fn().mockResolvedValue(undefined),
18+
},
19+
}))
20+
21+
vi.mock("@roo-code/ipc", () => ({
22+
IpcServer: class {},
23+
}))
24+
25+
vi.mock("../../activate/registerCommands", () => ({
26+
openClineInNewTab: openClineInNewTabMock,
27+
}))
28+
29+
vi.mock("../../integrations/terminal/Terminal", () => ({
30+
Terminal: {
31+
getTerminalProfile: vi.fn(),
32+
setTerminalProfile: vi.fn(),
33+
},
34+
}))
35+
36+
vi.mock("../../integrations/terminal/TerminalRegistry", () => ({
37+
TerminalRegistry: {
38+
closeIdleTerminals: vi.fn(),
39+
},
40+
}))
41+
42+
type CreatedTask = {
43+
taskId: string
44+
}
45+
46+
type ProviderDouble = EventEmitter & {
47+
context: vscode.ExtensionContext
48+
evictCurrentTask: Mock<() => Promise<void>>
49+
postStateToWebview: Mock<() => Promise<void>>
50+
postMessageToWebview: Mock<(message: unknown) => Promise<void>>
51+
createTask: Mock<(...args: unknown[]) => Promise<CreatedTask>>
52+
getCurrentTaskStack: Mock<() => string[]>
53+
getCurrentTask: Mock<() => undefined>
54+
getState: Mock<() => Promise<{ customModes?: ModeConfig[] }>>
55+
handleModeSwitch: Mock<(mode: string) => Promise<void>>
56+
viewLaunched: boolean
57+
}
58+
59+
type TaskDouble = EventEmitter & {
60+
taskId: string
61+
parentTaskId?: string
62+
approveAsk: Mock<() => void>
63+
handleWebviewAskResponse: Mock<(response: "messageResponse", text?: string, images?: string[]) => void>
64+
}
65+
66+
const configuration: RooCodeSettings = {}
67+
68+
function asClineProvider(provider: ProviderDouble): ClineProvider {
69+
// ClineProvider has private members, so a structural test double requires an unknown bridge.
70+
return provider as unknown as ClineProvider
71+
}
72+
73+
function createProvider(taskId = "task-1"): ProviderDouble {
74+
const provider = new EventEmitter() as ProviderDouble
75+
provider.context = {} as vscode.ExtensionContext
76+
provider.evictCurrentTask = vi.fn().mockResolvedValue(undefined)
77+
provider.postStateToWebview = vi.fn().mockResolvedValue(undefined)
78+
provider.postMessageToWebview = vi.fn().mockResolvedValue(undefined)
79+
provider.createTask = vi.fn().mockResolvedValue({ taskId })
80+
provider.getCurrentTaskStack = vi.fn().mockReturnValue([])
81+
provider.getCurrentTask = vi.fn().mockReturnValue(undefined)
82+
provider.getState = vi.fn().mockResolvedValue({ customModes: [] })
83+
provider.handleModeSwitch = vi.fn().mockResolvedValue(undefined)
84+
provider.viewLaunched = true
85+
return provider
86+
}
87+
88+
function createTask(taskId: string): TaskDouble {
89+
const task = new EventEmitter() as TaskDouble
90+
task.taskId = taskId
91+
task.approveAsk = vi.fn()
92+
task.handleWebviewAskResponse = vi.fn()
93+
return task
94+
}
95+
96+
describe("API task controls", () => {
97+
let outputChannel: vscode.OutputChannel
98+
let sidebarProvider: ProviderDouble
99+
let api: API
100+
101+
beforeEach(() => {
102+
vi.clearAllMocks()
103+
outputChannel = { appendLine: vi.fn() } as unknown as vscode.OutputChannel
104+
sidebarProvider = createProvider("sidebar-task")
105+
api = new API(outputChannel, asClineProvider(sidebarProvider))
106+
})
107+
108+
describe("startNewTask", () => {
109+
it("reverts and closes existing editors before opening a new tab unless preserveOpenTabs is true", async () => {
110+
const newTabProvider = createProvider("new-tab-task")
111+
openClineInNewTabMock.mockResolvedValue(newTabProvider)
112+
113+
const taskId = await api.startNewTask({ configuration, text: "new task", newTab: true })
114+
115+
expect(taskId).toBe("new-tab-task")
116+
expect(vscode.commands.executeCommand).toHaveBeenNthCalledWith(1, "workbench.action.files.revert")
117+
expect(vscode.commands.executeCommand).toHaveBeenNthCalledWith(2, "workbench.action.closeAllEditors")
118+
expect(openClineInNewTabMock).toHaveBeenCalledWith({
119+
context: sidebarProvider.context,
120+
outputChannel,
121+
})
122+
expect(newTabProvider.evictCurrentTask).toHaveBeenCalledOnce()
123+
expect(newTabProvider.createTask).toHaveBeenCalledWith(
124+
"new task",
125+
undefined,
126+
undefined,
127+
{ consecutiveMistakeLimit: Number.MAX_SAFE_INTEGER },
128+
configuration,
129+
)
130+
})
131+
132+
it("opens a new tab without revert or close commands when preserveOpenTabs is true", async () => {
133+
const newTabProvider = createProvider("preserved-tab-task")
134+
openClineInNewTabMock.mockResolvedValue(newTabProvider)
135+
136+
const taskId = await api.startNewTask({
137+
configuration,
138+
text: "keep editors",
139+
newTab: true,
140+
preserveOpenTabs: true,
141+
})
142+
143+
expect(taskId).toBe("preserved-tab-task")
144+
expect(vscode.commands.executeCommand).not.toHaveBeenCalled()
145+
expect(openClineInNewTabMock).toHaveBeenCalledWith({
146+
context: sidebarProvider.context,
147+
outputChannel,
148+
})
149+
expect(newTabProvider.createTask).toHaveBeenCalledWith(
150+
"keep editors",
151+
undefined,
152+
undefined,
153+
{ consecutiveMistakeLimit: Number.MAX_SAFE_INTEGER },
154+
configuration,
155+
)
156+
})
157+
})
158+
159+
describe("task ask registry", () => {
160+
it("returns false when approving an unknown task", async () => {
161+
await expect(api.approveTaskAsk("missing-task")).resolves.toBe(false)
162+
})
163+
164+
it("registers tasks on TaskCreated and approves a task by id", async () => {
165+
const task = createTask("task-to-approve")
166+
167+
sidebarProvider.emit(RooCodeEventName.TaskCreated, task)
168+
169+
await expect(api.approveTaskAsk(task.taskId)).resolves.toBe(true)
170+
expect(task.approveAsk).toHaveBeenCalledOnce()
171+
})
172+
173+
it("removes completed, aborted, and unfocused tasks from the registry", async () => {
174+
const completedTask = createTask("completed-task")
175+
sidebarProvider.emit(RooCodeEventName.TaskCreated, completedTask)
176+
completedTask.emit(RooCodeEventName.TaskCompleted, completedTask.taskId, {}, {})
177+
178+
await expect(api.approveTaskAsk(completedTask.taskId)).resolves.toBe(false)
179+
180+
const abortedTask = createTask("aborted-task")
181+
sidebarProvider.emit(RooCodeEventName.TaskCreated, abortedTask)
182+
abortedTask.emit(RooCodeEventName.TaskAborted)
183+
184+
await expect(api.approveTaskAsk(abortedTask.taskId)).resolves.toBe(false)
185+
186+
const unfocusedTask = createTask("unfocused-task")
187+
sidebarProvider.emit(RooCodeEventName.TaskCreated, unfocusedTask)
188+
unfocusedTask.emit(RooCodeEventName.TaskUnfocused)
189+
190+
await expect(api.approveTaskAsk(unfocusedTask.taskId)).resolves.toBe(false)
191+
})
192+
})
193+
194+
describe("selectTaskFollowupSuggestion", () => {
195+
it("returns false when the task is unknown", async () => {
196+
await expect(
197+
api.selectTaskFollowupSuggestion({ taskId: "missing-task", answer: "Use this" }),
198+
).resolves.toBe(false)
199+
})
200+
201+
it("responds to the task without switching modes when no mode is provided", async () => {
202+
const task = createTask("task-without-mode")
203+
sidebarProvider.emit(RooCodeEventName.TaskCreated, task)
204+
205+
await expect(api.selectTaskFollowupSuggestion({ taskId: task.taskId, answer: "Continue" })).resolves.toBe(
206+
true,
207+
)
208+
209+
expect(sidebarProvider.getState).not.toHaveBeenCalled()
210+
expect(sidebarProvider.handleModeSwitch).not.toHaveBeenCalled()
211+
expect(task.handleWebviewAskResponse).toHaveBeenCalledWith("messageResponse", "Continue")
212+
})
213+
214+
it("switches to a valid built-in mode before responding", async () => {
215+
const task = createTask("task-built-in-mode")
216+
sidebarProvider.emit(RooCodeEventName.TaskCreated, task)
217+
218+
await expect(
219+
api.selectTaskFollowupSuggestion({ taskId: task.taskId, answer: "Use architect", mode: "architect" }),
220+
).resolves.toBe(true)
221+
222+
expect(sidebarProvider.getState).toHaveBeenCalledOnce()
223+
expect(sidebarProvider.handleModeSwitch).toHaveBeenCalledWith("architect")
224+
expect(task.handleWebviewAskResponse).toHaveBeenCalledWith("messageResponse", "Use architect")
225+
})
226+
227+
it("responds without switching modes and logs when the requested mode is invalid", async () => {
228+
const task = createTask("task-invalid-mode")
229+
api = new API(outputChannel, asClineProvider(sidebarProvider), undefined, true)
230+
sidebarProvider.emit(RooCodeEventName.TaskCreated, task)
231+
232+
await expect(
233+
api.selectTaskFollowupSuggestion({ taskId: task.taskId, answer: "Use invalid", mode: "not-a-mode" }),
234+
).resolves.toBe(true)
235+
236+
expect(sidebarProvider.getState).toHaveBeenCalledOnce()
237+
expect(sidebarProvider.handleModeSwitch).not.toHaveBeenCalled()
238+
expect(task.handleWebviewAskResponse).toHaveBeenCalledWith("messageResponse", "Use invalid")
239+
expect(outputChannel.appendLine).toHaveBeenCalledWith(
240+
'[API#selectTaskFollowupSuggestion] ignoring unknown mode "not-a-mode" for task task-invalid-mode',
241+
)
242+
})
243+
244+
it("treats custom modes from the task provider state as valid", async () => {
245+
const task = createTask("task-custom-mode")
246+
const customMode: ModeConfig = {
247+
slug: "custom-review",
248+
name: "Custom Review",
249+
roleDefinition: "Review the implementation",
250+
groups: ["read"],
251+
}
252+
sidebarProvider.getState.mockResolvedValue({ customModes: [customMode] })
253+
sidebarProvider.emit(RooCodeEventName.TaskCreated, task)
254+
255+
await expect(
256+
api.selectTaskFollowupSuggestion({ taskId: task.taskId, answer: "Review it", mode: customMode.slug }),
257+
).resolves.toBe(true)
258+
259+
expect(sidebarProvider.handleModeSwitch).toHaveBeenCalledWith(customMode.slug)
260+
expect(task.handleWebviewAskResponse).toHaveBeenCalledWith("messageResponse", "Review it")
261+
})
262+
})
263+
})

0 commit comments

Comments
 (0)