fix review comment

chang default model for copilot
refactor the message handler about copilot
remove useless console ouput

Author: NaccOll

packages/types/src/providers/copilot.ts

@@ -1,4 +1,4 @@
-export const copilotDefaultModelId = "claude-sonnet-4"
+export const copilotDefaultModelId = "gpt-4.1"
 
 export const GITHUB_CLIENT_ID = "Iv1.b507a08c87ecfe98"
 export const GITHUB_DEVICE_CODE_URL = "https://github.com/login/device/code"

src/api/providers/fetchers/copilot.ts

@@ -173,12 +173,6 @@ export class CopilotAuthenticator {
 				expires_in: deviceData.expires_in,
 				interval: deviceData.interval || 5,
 			})
-		} else {
-			// Fallback to console logging
-			console.log(`\n🔐 Copilot Authentication Required`)
-			console.log(`Please visit: ${deviceData.verification_uri}`)
-			console.log(`Enter code: ${deviceData.user_code}`)
-			console.log(`Waiting for authentication...\n`)
 		}
 
 		// Step 3: Poll for access token

src/core/webview/message-handle/copilot/authenticateCopilot.ts

@@ -0,0 +1,49 @@
+import { MessageHandlerStrategy, MessageHandlerContext } from "../types"
+import { CopilotAuthenticator } from "../../../../api/providers/fetchers/copilot"
+
+/**
+ * Strategy for handling authenticateCopilot message
+ */
+export class AuthenticateCopilotStrategy implements MessageHandlerStrategy {
+	async handle(context: MessageHandlerContext): Promise<boolean> {
+		const { provider } = context
+
+		// Start device code authentication for Copilot
+		try {
+			const authenticator = CopilotAuthenticator.getInstance()
+
+			// Set up callbacks
+			authenticator.setDeviceCodeCallback((deviceInfo) => {
+				provider.postMessageToWebview({
+					type: "copilotDeviceCode",
+					copilotDeviceCode: {
+						user_code: deviceInfo.user_code,
+						verification_uri: deviceInfo.verification_uri,
+						expires_in: deviceInfo.expires_in,
+					},
+				})
+			})
+
+			authenticator.setAuthTimeoutCallback((error) => {
+				provider.postMessageToWebview({
+					type: "copilotAuthError",
+					error: error,
+				})
+			})
+
+			await authenticator.getApiKey() // This will trigger the device code flow
+			provider.postMessageToWebview({
+				type: "copilotAuthStatus",
+				copilotAuthenticated: true,
+			})
+			return true
+		} catch (error) {
+			console.error("Failed to authenticate with Copilot:", error)
+			provider.postMessageToWebview({
+				type: "copilotAuthError",
+				error: error instanceof Error ? error.message : "Authentication failed",
+			})
+			return false
+		}
+	}
+}

src/core/webview/message-handle/copilot/checkCopilotAuth.ts

@@ -0,0 +1,30 @@
+import { MessageHandlerStrategy, MessageHandlerContext } from "../types"
+import { CopilotAuthenticator } from "../../../../api/providers/fetchers/copilot"
+
+/**
+ * Strategy for handling checkCopilotAuth message
+ */
+export class CheckCopilotAuthStrategy implements MessageHandlerStrategy {
+	async handle(context: MessageHandlerContext): Promise<boolean> {
+		const { provider } = context
+
+		try {
+			const authenticator = CopilotAuthenticator.getInstance()
+			const isAuthenticated = await authenticator.isAuthenticated()
+
+			provider.postMessageToWebview({
+				type: "copilotModels",
+				copilotAuthenticated: isAuthenticated,
+			})
+			return true
+		} catch (error) {
+			console.error("Failed to check Copilot auth:", error)
+			provider.postMessageToWebview({
+				type: "copilotModels",
+				copilotAuthenticated: false,
+				error: error instanceof Error ? error.message : "Unknown error",
+			})
+			return true
+		}
+	}
+}

src/core/webview/message-handle/copilot/clearCopilotAuth.ts

@@ -0,0 +1,31 @@
+import { MessageHandlerStrategy, MessageHandlerContext } from "../types"
+import { CopilotAuthenticator } from "../../../../api/providers/fetchers/copilot"
+
+/**
+ * Strategy for handling clearCopilotAuth message
+ */
+export class ClearCopilotAuthStrategy implements MessageHandlerStrategy {
+	async handle(context: MessageHandlerContext): Promise<boolean> {
+		const { provider } = context
+
+		try {
+			const authenticator = CopilotAuthenticator.getInstance()
+			await authenticator.clearAuth()
+
+			provider.postMessageToWebview({
+				type: "copilotModels",
+				copilotModels: {},
+				success: true,
+			})
+			return true
+		} catch (error) {
+			console.error("Failed to clear Copilot auth:", error)
+			provider.postMessageToWebview({
+				type: "copilotModels",
+				copilotModels: {},
+				error: error instanceof Error ? error.message : "Unknown error",
+			})
+			return true
+		}
+	}
+}

src/core/webview/message-handle/copilot/index.ts

@@ -0,0 +1,29 @@
+/**
+ * Copilot message handling module
+ *
+ * This module implements the Strategy pattern for handling Copilot-related messages.
+ * Each message type has its own dedicated handler that implements the MessageHandler interface.
+ *
+ * Supported message types:
+ * - requestCopilotModels: Fetches available Copilot models
+ * - authenticateCopilot: Initiates Copilot authentication flow
+ * - clearCopilotAuth: Clears stored Copilot authentication
+ * - checkCopilotAuth: Checks current Copilot authentication status
+ */
+
+import { RequestCopilotModelsStrategy } from "./requestCopilotModels"
+import { AuthenticateCopilotStrategy } from "./authenticateCopilot"
+import { ClearCopilotAuthStrategy } from "./clearCopilotAuth"
+import { CheckCopilotAuthStrategy } from "./checkCopilotAuth"
+import { MessageHandlerRegistry } from "../types"
+
+/**
+ * Register all Copilot-related message handler strategies
+ */
+export function registerCopilotStrategies(messageHandlerRegistry: MessageHandlerRegistry): void {
+	// Register each strategy with its corresponding message type
+	messageHandlerRegistry.registerStrategy("requestCopilotModels", new RequestCopilotModelsStrategy())
+	messageHandlerRegistry.registerStrategy("authenticateCopilot", new AuthenticateCopilotStrategy())
+	messageHandlerRegistry.registerStrategy("clearCopilotAuth", new ClearCopilotAuthStrategy())
+	messageHandlerRegistry.registerStrategy("checkCopilotAuth", new CheckCopilotAuthStrategy())
+}

src/core/webview/message-handle/copilot/requestCopilotModels.ts

@@ -0,0 +1,30 @@
+import { MessageHandlerStrategy, MessageHandlerContext } from "../types"
+import { getCopilotModels } from "../../../../api/providers/fetchers/copilot"
+import { ModelRecord } from "../../../../shared/api"
+
+/**
+ * Strategy for handling requestCopilotModels message
+ */
+export class RequestCopilotModelsStrategy implements MessageHandlerStrategy {
+	async handle(context: MessageHandlerContext): Promise<boolean> {
+		const { provider } = context
+
+		try {
+			const copilotModels = await getCopilotModels()
+			provider.postMessageToWebview({
+				type: "copilotModels",
+				copilotModels,
+			})
+			return true
+		} catch (error) {
+			console.error("Failed to request Copilot models:", error)
+			// Return empty ModelRecord on error
+			const emptyModels: ModelRecord = {}
+			provider.postMessageToWebview({
+				type: "copilotModels",
+				copilotModels: emptyModels,
+			})
+			return true
+		}
+	}
+}

src/core/webview/message-handle/index.ts

@@ -0,0 +1,2 @@
+export * from "./types"
+export * from "./registry"

src/core/webview/message-handle/registry.ts

@@ -0,0 +1,71 @@
+import { MarketplaceManager } from "../../../services/marketplace"
+import { WebviewMessage } from "../../../shared/WebviewMessage"
+import { ClineProvider } from "../ClineProvider"
+import { registerCopilotStrategies } from "./copilot"
+import { MessageHandlerStrategy, MessageHandlerRegistry, MessageHandlerContext } from "./types"
+
+/**
+ * Central registry for message handler strategies
+ * Implements strategy pattern with key-based registration
+ */
+export class DefaultMessageHandlerRegistry implements MessageHandlerRegistry {
+	private static instance: DefaultMessageHandlerRegistry | null = null
+	private strategies: Map<string, MessageHandlerStrategy> = new Map()
+
+	private constructor() {}
+
+	public static getInstance() {
+		if (DefaultMessageHandlerRegistry.instance === null) {
+			DefaultMessageHandlerRegistry.instance = new DefaultMessageHandlerRegistry()
+			registerCopilotStrategies(DefaultMessageHandlerRegistry.instance)
+		}
+		return DefaultMessageHandlerRegistry.instance
+	}
+
+	/**
+	 * Registers a strategy for handling a specific message type
+	 */
+	registerStrategy(messageType: string, strategy: MessageHandlerStrategy): void {
+		this.strategies.set(messageType, strategy)
+	}
+
+	/**
+	 * Gets a strategy for the given message type
+	 */
+	getStrategy(messageType: string): MessageHandlerStrategy | null {
+		return this.strategies.get(messageType) || null
+	}
+
+	/**
+	 * Gets all registered message types
+	 */
+	getSupportedTypes(): string[] {
+		return Array.from(this.strategies.keys())
+	}
+
+	async handleMessage(
+		provider: ClineProvider,
+		message: WebviewMessage,
+		marketplaceManager?: MarketplaceManager,
+	): Promise<boolean> {
+		const context: MessageHandlerContext = {
+			provider,
+			message,
+			marketplaceManager,
+		}
+
+		const strategy = this.getStrategy(context.message.type)
+
+		if (strategy) {
+			try {
+				return await strategy.handle(context)
+			} catch (error) {
+				console.error(`Error handling message type "${context.message.type}":`, error)
+				return false
+			}
+		}
+
+		// Message type not supported by any registered strategy
+		return false
+	}
+}

src/core/webview/message-handle/types.ts

@@ -0,0 +1,52 @@
+import { ClineProvider } from "../ClineProvider"
+import { WebviewMessage } from "../../../shared/WebviewMessage"
+import { MarketplaceManager } from "../../../services/marketplace"
+
+/**
+ * Context provided to message handlers
+ */
+export interface MessageHandlerContext {
+	/** The ClineProvider instance */
+	provider: ClineProvider
+	/** The webview message to handle */
+	message: WebviewMessage
+	/** Optional marketplace manager */
+	marketplaceManager?: MarketplaceManager
+}
+
+/**
+ * Strategy interface for handling specific message types
+ */
+export interface MessageHandlerStrategy {
+	/**
+	 * Handles a specific webview message type
+	 * @param context The message handler context
+	 * @returns Promise<boolean> indicating whether the message was handled
+	 */
+	handle(context: MessageHandlerContext): Promise<boolean>
+}
+
+/**
+ * Registry for message handler strategies
+ */
+export interface MessageHandlerRegistry {
+	/**
+	 * Registers a strategy for handling a specific message type
+	 * @param messageType The type of message to handle
+	 * @param strategy The strategy to register
+	 */
+	registerStrategy(messageType: string, strategy: MessageHandlerStrategy): void
+
+	/**
+	 * Gets a strategy for the given message type
+	 * @param messageType The type of message to handle
+	 * @returns MessageHandlerStrategy instance or null if not supported
+	 */
+	getStrategy(messageType: string): MessageHandlerStrategy | null
+
+	/**
+	 * Gets all registered message types
+	 * @returns Array of supported message type strings
+	 */
+	getSupportedTypes(): string[]
+}