Cloud: convert CloudService to an EventEmitter

Author: jr

packages/cloud/src/CloudService.ts

@@ -1,4 +1,5 @@
 import * as vscode from "vscode"
+import EventEmitter from "events"
 
 import type {
 	CloudUserInfo,
@@ -10,7 +11,7 @@ import type {
 } from "@roo-code/types"
 import { TelemetryService } from "@roo-code/telemetry"
 
-import { CloudServiceCallbacks } from "./types"
+import { CloudServiceEvents } from "./types"
 import type { AuthService } from "./auth"
 import { WebAuthService, StaticTokenAuthService } from "./auth"
 import type { SettingsService } from "./SettingsService"
@@ -19,29 +20,37 @@ import { StaticSettingsService } from "./StaticSettingsService"
 import { TelemetryClient } from "./TelemetryClient"
 import { ShareService, TaskNotFoundError } from "./ShareService"
 
-export class CloudService {
+type AuthStateChangedPayload = CloudServiceEvents["auth-state-changed"][0]
+type AuthUserInfoPayload = CloudServiceEvents["user-info"][0]
+type SettingsPayload = CloudServiceEvents["settings-updated"][0]
+
+export class CloudService extends EventEmitter<CloudServiceEvents> {
 	private static _instance: CloudService | null = null
 
 	private context: vscode.ExtensionContext
-	private callbacks: CloudServiceCallbacks
-	private authListener: () => void
+	private authStateListener: (data: AuthStateChangedPayload) => void
+	private authUserInfoListener: (data: AuthUserInfoPayload) => void
 	private authService: AuthService | null = null
-	private settingsListener: () => void
+	private settingsListener: (data: SettingsPayload) => void
 	private settingsService: SettingsService | null = null
 	private telemetryClient: TelemetryClient | null = null
 	private shareService: ShareService | null = null
 	private isInitialized = false
 	private log: (...args: unknown[]) => void
 
-	private constructor(context: vscode.ExtensionContext, callbacks: CloudServiceCallbacks) {
+	private constructor(context: vscode.ExtensionContext, log?: (...args: unknown[]) => void) {
+		super()
+
 		this.context = context
-		this.callbacks = callbacks
-		this.log = callbacks.log || console.log
-		this.authListener = () => {
-			this.callbacks.stateChanged?.()
+		this.log = log || console.log
+		this.authStateListener = (data: AuthStateChangedPayload) => {
+			this.emit("auth-state-changed", data)
+		}
+		this.authUserInfoListener = (data: AuthUserInfoPayload) => {
+			this.emit("user-info", data)
 		}
-		this.settingsListener = () => {
-			this.callbacks.stateChanged?.()
+		this.settingsListener = (data: SettingsPayload) => {
+			this.emit("settings-updated", data)
 		}
 	}
 
@@ -61,8 +70,8 @@ export class CloudService {
 
 			await this.authService.initialize()
 
-			this.authService.on("auth-state-changed", this.authListener)
-			this.authService.on("user-info", this.authListener)
+			this.authService.on("auth-state-changed", this.authStateListener)
+			this.authService.on("user-info", this.authUserInfoListener)
 
 			// Check for static settings environment variable.
 			const staticOrgSettings = process.env.ROO_CODE_CLOUD_ORG_SETTINGS
@@ -217,8 +226,8 @@ export class CloudService {
 
 	public dispose(): void {
 		if (this.authService) {
-			this.authService.off("auth-state-changed", this.authListener)
-			this.authService.off("user-info", this.authListener)
+			this.authService.off("auth-state-changed", this.authStateListener)
+			this.authService.off("user-info", this.authUserInfoListener)
 		}
 		if (this.settingsService) {
 			if (this.settingsService instanceof CloudSettingsService) {
@@ -246,13 +255,13 @@ export class CloudService {
 
 	static async createInstance(
 		context: vscode.ExtensionContext,
-		callbacks: CloudServiceCallbacks = {},
+		log?: (...args: unknown[]) => void,
 	): Promise<CloudService> {
 		if (this._instance) {
 			throw new Error("CloudService instance already created")
 		}
 
-		this._instance = new CloudService(context, callbacks)
+		this._instance = new CloudService(context, log)
 		await this._instance.initialize()
 		return this._instance
 	}

packages/cloud/src/__tests__/CloudService.test.ts

@@ -9,7 +9,6 @@ import { CloudSettingsService } from "../CloudSettingsService"
 import { ShareService, TaskNotFoundError } from "../ShareService"
 import { TelemetryClient } from "../TelemetryClient"
 import { TelemetryService } from "@roo-code/telemetry"
-import { CloudServiceCallbacks } from "../types"
 
 vi.mock("vscode", () => ({
 	ExtensionContext: vi.fn(),
@@ -172,23 +171,19 @@ describe("CloudService", () => {
 
 	describe("createInstance", () => {
 		it("should create and initialize CloudService instance", async () => {
-			const callbacks = {
-				stateChanged: vi.fn(),
-			}
+			const mockLog = vi.fn()
 
-			const cloudService = await CloudService.createInstance(mockContext, callbacks)
+			const cloudService = await CloudService.createInstance(mockContext, mockLog)
 
 			expect(cloudService).toBeInstanceOf(CloudService)
 			expect(WebAuthService).toHaveBeenCalledWith(mockContext, expect.any(Function))
 			expect(CloudSettingsService).toHaveBeenCalledWith(mockContext, mockAuthService, expect.any(Function))
 		})
 
 		it("should set up event listeners for CloudSettingsService", async () => {
-			const callbacks = {
-				stateChanged: vi.fn(),
-			}
+			const mockLog = vi.fn()
 
-			await CloudService.createInstance(mockContext, callbacks)
+			await CloudService.createInstance(mockContext, mockLog)
 
 			expect(mockSettingsService.on).toHaveBeenCalledWith("settings-updated", expect.any(Function))
 		})
@@ -204,11 +199,9 @@ describe("CloudService", () => {
 
 	describe("authentication methods", () => {
 		let cloudService: CloudService
-		let callbacks: CloudServiceCallbacks
 
 		beforeEach(async () => {
-			callbacks = { stateChanged: vi.fn() }
-			cloudService = await CloudService.createInstance(mockContext, callbacks)
+			cloudService = await CloudService.createInstance(mockContext)
 		})
 
 		it("should delegate login to AuthService", async () => {
@@ -457,23 +450,24 @@ describe("CloudService", () => {
 
 	describe("settings event handling", () => {
 		let _cloudService: CloudService
-		let callbacks: CloudServiceCallbacks
 
 		beforeEach(async () => {
-			callbacks = { stateChanged: vi.fn() }
-			_cloudService = await CloudService.createInstance(mockContext, callbacks)
+			_cloudService = await CloudService.createInstance(mockContext)
 		})
 
-		it("should call stateChanged callback when settings are updated", async () => {
-			// Get the settings listener that was registered
-			const settingsListener = mockSettingsService.on.mock.calls.find(
+		it("should emit settings-updated event when settings are updated", async () => {
+			const settingsListener = vi.fn()
+			_cloudService.on("settings-updated", settingsListener)
+
+			// Get the settings listener that was registered with the settings service
+			const serviceSettingsListener = mockSettingsService.on.mock.calls.find(
 				(call) => call[0] === "settings-updated",
 			)?.[1]
 
-			expect(settingsListener).toBeDefined()
+			expect(serviceSettingsListener).toBeDefined()
 
 			// Simulate settings update event
-			settingsListener({
+			const settingsData = {
 				settings: {
 					version: 2,
 					defaultSettings: {},
@@ -484,9 +478,10 @@ describe("CloudService", () => {
 					defaultSettings: {},
 					allowList: { allowAll: true, providers: {} },
 				},
-			})
+			}
+			serviceSettingsListener(settingsData)
 
-			expect(callbacks.stateChanged).toHaveBeenCalled()
+			expect(settingsListener).toHaveBeenCalledWith(settingsData)
 		})
 	})
 
@@ -503,7 +498,7 @@ describe("CloudService", () => {
 			mockAuthService.hasOrIsAcquiringActiveSession.mockReturnValue(true)
 			mockAuthService.getState.mockReturnValue("active")
 
-			cloudService = await CloudService.createInstance(mockContext, {})
+			cloudService = await CloudService.createInstance(mockContext)
 		})
 
 		it("should call shareTask without retry when successful", async () => {

packages/cloud/src/types.ts

@@ -1,4 +1,4 @@
-export interface CloudServiceCallbacks {
-	stateChanged?: () => void
-	log?: (...args: unknown[]) => void
-}
+import { AuthServiceEvents } from "./auth"
+import { SettingsServiceEvents } from "./CloudSettingsService"
+
+export type CloudServiceEvents = AuthServiceEvents & SettingsServiceEvents

src/extension.ts

@@ -75,10 +75,15 @@ export async function activate(context: vscode.ExtensionContext) {
 	const cloudLogger = createDualLogger(createOutputChannelLogger(outputChannel))
 
 	// Initialize Roo Code Cloud service.
-	await CloudService.createInstance(context, {
-		stateChanged: () => ClineProvider.getVisibleInstance()?.postStateToWebview(),
-		log: cloudLogger,
-	})
+	const cloudService = await CloudService.createInstance(context, cloudLogger)
+	const postStateListener = () => {
+		ClineProvider.getVisibleInstance()?.postStateToWebview()
+	}
+	cloudService.on("auth-state-changed", postStateListener)
+	cloudService.on("user-info", postStateListener)
+	cloudService.on("settings-updated", postStateListener)
+	// Add to subscriptions for proper cleanup on deactivate
+	context.subscriptions.push(cloudService)
 
 	// Initialize MDM service
 	const mdmService = await MdmService.createInstance(cloudLogger)