feat(Task): keep track of active running task

Author: edelauna

src/core/task/Task.ts

@@ -405,6 +405,7 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 	didToolFailInCurrentTurn = false
 	didCompleteReadingStream = false
 	private _started = false
+	private _runPromise: Promise<void> | undefined
 	// No streaming parser is required.
 	assistantMessageParser?: undefined
 	private providerProfileChangeListener?: (config: { name: string; provider?: string }) => void
@@ -1875,6 +1876,27 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 		}
 	}
 
+	/**
+	 * Like `start()`, but returns the underlying promise so callers (e.g.
+	 * `TaskScheduler`) can await task completion and gate concurrency.
+	 * Idempotent: subsequent calls return the same in-flight promise.
+	 */
+	public run(): Promise<void> {
+		if (this._runPromise !== undefined) {
+			return this._runPromise
+		}
+		if (this._started) {
+			// Already launched via constructor or start() — no promise to return.
+			return Promise.resolve()
+		}
+		this._started = true
+
+		const { task, images } = this.metadata
+
+		this._runPromise = task || images ? this.startTask(task ?? undefined, images ?? undefined) : Promise.resolve()
+		return this._runPromise
+	}
+
 	private async startTask(task?: string, images?: string[]): Promise<void> {
 		try {
 			// `conversationHistory` (for API) and `clineMessages` (for webview)

src/core/task/__tests__/Task.dispose.test.ts

@@ -1,4 +1,4 @@
-import { ProviderSettings } from "@roo-code/types"
+import { type ProviderSettings, RooCodeEventName } from "@roo-code/types"
 
 import { Task } from "../Task"
 import { ClineProvider } from "../../webview/ClineProvider"
@@ -44,7 +44,11 @@ vi.mock("@roo-code/telemetry", () => ({
 }))
 
 describe("Task dispose method", () => {
-	let mockProvider: any
+	let mockProvider: {
+		context: { globalStorageUri: { fsPath: string } }
+		getState: ReturnType<typeof vi.fn>
+		log: ReturnType<typeof vi.fn>
+	}
 	let mockApiConfiguration: ProviderSettings
 	let task: Task
 
@@ -69,7 +73,7 @@ describe("Task dispose method", () => {
 
 		// Create task instance without starting it
 		task = new Task({
-			provider: mockProvider as ClineProvider,
+			provider: mockProvider as unknown as ClineProvider,
 			apiConfiguration: mockApiConfiguration,
 			startTask: false,
 		})
@@ -88,15 +92,14 @@ describe("Task dispose method", () => {
 		const listener2 = vi.fn(() => {})
 		const listener3 = vi.fn((taskId: string) => {})
 
-		// Use type assertion to bypass strict event typing for testing
-		;(task as any).on("TaskStarted", listener1)
-		;(task as any).on("TaskAborted", listener2)
-		;(task as any).on("TaskIdle", listener3)
+		task.on(RooCodeEventName.TaskStarted, listener1)
+		task.on(RooCodeEventName.TaskAborted, listener2)
+		task.on(RooCodeEventName.TaskIdle, listener3)
 
 		// Verify listeners are added
-		expect(task.listenerCount("TaskStarted")).toBe(1)
-		expect(task.listenerCount("TaskAborted")).toBe(1)
-		expect(task.listenerCount("TaskIdle")).toBe(1)
+		expect(task.listenerCount(RooCodeEventName.TaskStarted)).toBe(1)
+		expect(task.listenerCount(RooCodeEventName.TaskAborted)).toBe(1)
+		expect(task.listenerCount(RooCodeEventName.TaskIdle)).toBe(1)
 
 		// Spy on removeAllListeners method
 		const removeAllListenersSpy = vi.spyOn(task, "removeAllListeners")
@@ -108,9 +111,9 @@ describe("Task dispose method", () => {
 		expect(removeAllListenersSpy).toHaveBeenCalledOnce()
 
 		// Verify all listeners are removed
-		expect(task.listenerCount("TaskStarted")).toBe(0)
-		expect(task.listenerCount("TaskAborted")).toBe(0)
-		expect(task.listenerCount("TaskIdle")).toBe(0)
+		expect(task.listenerCount(RooCodeEventName.TaskStarted)).toBe(0)
+		expect(task.listenerCount(RooCodeEventName.TaskAborted)).toBe(0)
+		expect(task.listenerCount(RooCodeEventName.TaskIdle)).toBe(0)
 	})
 
 	test("should handle errors when removing event listeners", () => {
@@ -158,53 +161,125 @@ describe("Task dispose method", () => {
 		const listeners = {
 			TaskStarted: vi.fn(() => {}),
 			TaskAborted: vi.fn(() => {}),
-			TaskIdle: vi.fn((taskId: string) => {}),
-			TaskActive: vi.fn((taskId: string) => {}),
+			TaskIdle: vi.fn((_taskId: string) => {}),
+			TaskActive: vi.fn((_taskId: string) => {}),
 			TaskAskResponded: vi.fn(() => {}),
-			Message: vi.fn((data: { action: "created" | "updated"; message: any }) => {}),
-			TaskTokenUsageUpdated: vi.fn((taskId: string, tokenUsage: any) => {}),
-			TaskToolFailed: vi.fn((taskId: string, tool: any, error: string) => {}),
-			TaskUnpaused: vi.fn(() => {}),
+			Message: vi.fn(() => {}),
+			TaskTokenUsageUpdated: vi.fn(() => {}),
+			TaskToolFailed: vi.fn(() => {}),
+			TaskUnpaused: vi.fn((_taskId: string) => {}),
 		}
 
-		// Add all listeners using type assertion to bypass strict typing for testing
-		const taskAny = task as any
-		taskAny.on("TaskStarted", listeners.TaskStarted)
-		taskAny.on("TaskAborted", listeners.TaskAborted)
-		taskAny.on("TaskIdle", listeners.TaskIdle)
-		taskAny.on("TaskActive", listeners.TaskActive)
-		taskAny.on("TaskAskResponded", listeners.TaskAskResponded)
-		taskAny.on("Message", listeners.Message)
-		taskAny.on("TaskTokenUsageUpdated", listeners.TaskTokenUsageUpdated)
-		taskAny.on("TaskToolFailed", listeners.TaskToolFailed)
-		taskAny.on("TaskUnpaused", listeners.TaskUnpaused)
+		task.on(RooCodeEventName.TaskStarted, listeners.TaskStarted)
+		task.on(RooCodeEventName.TaskAborted, listeners.TaskAborted)
+		task.on(RooCodeEventName.TaskIdle, listeners.TaskIdle)
+		task.on(RooCodeEventName.TaskActive, listeners.TaskActive)
+		task.on(RooCodeEventName.TaskAskResponded, listeners.TaskAskResponded)
+		task.on(RooCodeEventName.Message, listeners.Message)
+		task.on(RooCodeEventName.TaskTokenUsageUpdated, listeners.TaskTokenUsageUpdated)
+		task.on(RooCodeEventName.TaskToolFailed, listeners.TaskToolFailed)
+		task.on(RooCodeEventName.TaskUnpaused, listeners.TaskUnpaused)
 
 		// Verify all listeners are added
-		expect(task.listenerCount("TaskStarted")).toBe(1)
-		expect(task.listenerCount("TaskAborted")).toBe(1)
-		expect(task.listenerCount("TaskIdle")).toBe(1)
-		expect(task.listenerCount("TaskActive")).toBe(1)
-		expect(task.listenerCount("TaskAskResponded")).toBe(1)
-		expect(task.listenerCount("Message")).toBe(1)
-		expect(task.listenerCount("TaskTokenUsageUpdated")).toBe(1)
-		expect(task.listenerCount("TaskToolFailed")).toBe(1)
-		expect(task.listenerCount("TaskUnpaused")).toBe(1)
+		expect(task.listenerCount(RooCodeEventName.TaskStarted)).toBe(1)
+		expect(task.listenerCount(RooCodeEventName.TaskAborted)).toBe(1)
+		expect(task.listenerCount(RooCodeEventName.TaskIdle)).toBe(1)
+		expect(task.listenerCount(RooCodeEventName.TaskActive)).toBe(1)
+		expect(task.listenerCount(RooCodeEventName.TaskAskResponded)).toBe(1)
+		expect(task.listenerCount(RooCodeEventName.Message)).toBe(1)
+		expect(task.listenerCount(RooCodeEventName.TaskTokenUsageUpdated)).toBe(1)
+		expect(task.listenerCount(RooCodeEventName.TaskToolFailed)).toBe(1)
+		expect(task.listenerCount(RooCodeEventName.TaskUnpaused)).toBe(1)
 
 		// Call dispose
 		task.dispose()
 
 		// Verify all listeners are removed
-		expect(task.listenerCount("TaskStarted")).toBe(0)
-		expect(task.listenerCount("TaskAborted")).toBe(0)
-		expect(task.listenerCount("TaskIdle")).toBe(0)
-		expect(task.listenerCount("TaskActive")).toBe(0)
-		expect(task.listenerCount("TaskAskResponded")).toBe(0)
-		expect(task.listenerCount("Message")).toBe(0)
-		expect(task.listenerCount("TaskTokenUsageUpdated")).toBe(0)
-		expect(task.listenerCount("TaskToolFailed")).toBe(0)
-		expect(task.listenerCount("TaskUnpaused")).toBe(0)
+		expect(task.listenerCount(RooCodeEventName.TaskStarted)).toBe(0)
+		expect(task.listenerCount(RooCodeEventName.TaskAborted)).toBe(0)
+		expect(task.listenerCount(RooCodeEventName.TaskIdle)).toBe(0)
+		expect(task.listenerCount(RooCodeEventName.TaskActive)).toBe(0)
+		expect(task.listenerCount(RooCodeEventName.TaskAskResponded)).toBe(0)
+		expect(task.listenerCount(RooCodeEventName.Message)).toBe(0)
+		expect(task.listenerCount(RooCodeEventName.TaskTokenUsageUpdated)).toBe(0)
+		expect(task.listenerCount(RooCodeEventName.TaskToolFailed)).toBe(0)
+		expect(task.listenerCount(RooCodeEventName.TaskUnpaused)).toBe(0)
 
 		// Verify total listener count is 0
 		expect(task.eventNames().length).toBe(0)
 	})
 })
+
+describe("Task.run() idempotency", () => {
+	// Reuses the mock setup from the outer describe block above.
+	let mockProvider: ReturnType<typeof buildMockProvider>
+	let mockApiConfiguration: ProviderSettings
+
+	function buildMockProvider() {
+		return {
+			context: { globalStorageUri: { fsPath: "/test/path" } },
+			getState: vi.fn().mockResolvedValue({ mode: "code" }),
+			log: vi.fn(),
+		}
+	}
+
+	beforeEach(() => {
+		vi.clearAllMocks()
+		mockProvider = buildMockProvider()
+		mockApiConfiguration = { apiProvider: "anthropic", apiKey: "test-key" } as ProviderSettings
+	})
+
+	test("run() does not invoke startTask when task was already started by constructor", async () => {
+		// Spy on the prototype before construction so we capture the constructor's call too.
+		const startTaskSpy = vi.spyOn(Task.prototype as any, "startTask").mockResolvedValue(undefined)
+
+		const t = new Task({
+			provider: mockProvider as unknown as ClineProvider,
+			apiConfiguration: mockApiConfiguration,
+			task: "hello",
+			startTask: true,
+		})
+
+		const callsBefore = startTaskSpy.mock.calls.length // constructor fired it once
+		void t.run()
+		expect(startTaskSpy.mock.calls.length).toBe(callsBefore) // run() must not add a second call
+		t.dispose()
+		startTaskSpy.mockRestore()
+	})
+
+	test("run() does not invoke startTask when task was already started by start()", async () => {
+		const startTaskSpy = vi.spyOn(Task.prototype as any, "startTask").mockResolvedValue(undefined)
+
+		const t = new Task({
+			provider: mockProvider as unknown as ClineProvider,
+			apiConfiguration: mockApiConfiguration,
+			task: "hello",
+			startTask: false,
+		})
+		t.start()
+		const callsAfterStart = startTaskSpy.mock.calls.length // start() fired it once
+
+		void t.run()
+		expect(startTaskSpy.mock.calls.length).toBe(callsAfterStart) // no additional call
+		t.dispose()
+		startTaskSpy.mockRestore()
+	})
+
+	test("run() returns the same promise on repeated calls", async () => {
+		const startTaskSpy = vi.spyOn(Task.prototype as any, "startTask").mockResolvedValue(undefined)
+
+		const t = new Task({
+			provider: mockProvider as unknown as ClineProvider,
+			apiConfiguration: mockApiConfiguration,
+			task: "hello",
+			startTask: false,
+		})
+
+		const p1 = t.run()
+		const p2 = t.run()
+		expect(p1).toBe(p2)
+		await p1
+		t.dispose()
+		startTaskSpy.mockRestore()
+	})
+})