refactor: move error recovery logic into startIndexing method

- Moved error recovery from webviewMessageHandler into CodeIndexManager.startIndexing()
- This ensures error recovery happens whenever indexing is started, not just from UI
- Added race condition prevention flag within CodeIndexManager
- Simplified webviewMessageHandler by removing error state checking
- The startIndexing method now automatically recovers from error state before proceeding

Author: daniel-lxs

src/core/webview/webviewMessageHandler.ts

@@ -55,9 +55,6 @@ const ALLOWED_VSCODE_SETTINGS = new Set(["terminal.integrated.inheritEnv"])
 import { MarketplaceManager, MarketplaceItemType } from "../../services/marketplace"
 import { setPendingTodoList } from "../tools/updateTodoListTool"
 
-// Flag to prevent race conditions during indexing recovery
-let isRecoveringFromIndexingError = false
-
 export const webviewMessageHandler = async (
 	provider: ClineProvider,
 	message: WebviewMessage,
@@ -2202,32 +2199,22 @@ export const webviewMessageHandler = async (
 					return
 				}
 				if (manager.isFeatureEnabled && manager.isFeatureConfigured) {
-					// Check if in error state and recover
-					const currentStatus = manager.getCurrentStatus()
-					if (currentStatus.systemStatus === "Error") {
-						// Prevent race conditions from multiple rapid clicks
-						if (isRecoveringFromIndexingError) {
-							provider.log("Indexing recovery already in progress, ignoring duplicate request")
-							return
-						}
-
-						isRecoveringFromIndexingError = true
-						try {
-							await manager.recoverFromError()
-						} finally {
-							isRecoveringFromIndexingError = false
-						}
+					if (!manager.isInitialized) {
+						await manager.initialize(provider.contextProxy)
 					}
 
+					// startIndexing now handles error recovery internally
+					await manager.startIndexing()
+
+					// If startIndexing recovered from error, we need to reinitialize
 					if (!manager.isInitialized) {
 						await manager.initialize(provider.contextProxy)
+						// Try starting again after initialization
+						await manager.startIndexing()
 					}
-
-					manager.startIndexing()
 				}
 			} catch (error) {
 				provider.log(`Error starting indexing: ${error instanceof Error ? error.message : String(error)}`)
-				isRecoveringFromIndexingError = false
 			}
 			break
 		}

src/services/code-index/manager.ts

@@ -28,6 +28,9 @@ export class CodeIndexManager {
 	private _searchService: CodeIndexSearchService | undefined
 	private _cacheManager: CacheManager | undefined
 
+	// Flag to prevent race conditions during error recovery
+	private _isRecoveringFromError = false
+
 	public static getInstance(context: vscode.ExtensionContext): CodeIndexManager | undefined {
 		// Use first workspace folder consistently
 		const workspaceFolders = vscode.workspace.workspaceFolders
@@ -157,12 +160,23 @@ export class CodeIndexManager {
 
 	/**
 	 * Initiates the indexing process (initial scan and starts watcher).
+	 * Automatically recovers from error state if needed before starting.
 	 */
-
 	public async startIndexing(): Promise<void> {
 		if (!this.isFeatureEnabled) {
 			return
 		}
+
+		// Check if we're in error state and recover if needed
+		const currentStatus = this.getCurrentStatus()
+		if (currentStatus.systemStatus === "Error") {
+			await this.recoverFromError()
+
+			// After recovery, we need to reinitialize since recoverFromError clears all services
+			// This will be handled by the caller (webviewMessageHandler) checking isInitialized
+			return
+		}
+
 		this.assertInitialized()
 		await this._orchestrator!.startIndexing()
 	}
@@ -191,22 +205,32 @@ export class CodeIndexManager {
 	 * - Safe to call even when not in error state (idempotent)
 	 * - Does not restart indexing automatically - call initialize() after recovery
 	 * - Service instances will be recreated on next initialize() call
+	 * - Prevents race conditions from multiple concurrent recovery attempts
 	 */
 	public async recoverFromError(): Promise<void> {
+		// Prevent race conditions from multiple rapid recovery attempts
+		if (this._isRecoveringFromError) {
+			return
+		}
+
+		this._isRecoveringFromError = true
 		try {
 			// Clear error state
 			this._stateManager.setSystemState("Standby", "")
 		} catch (error) {
 			// Log error but continue with recovery - clearing service instances is more important
 			console.error("Failed to clear error state during recovery:", error)
+		} finally {
+			// Force re-initialization by clearing service instances
+			// This ensures a clean slate even if state update failed
+			this._configManager = undefined
+			this._serviceFactory = undefined
+			this._orchestrator = undefined
+			this._searchService = undefined
+
+			// Reset the flag after recovery is complete
+			this._isRecoveringFromError = false
 		}
-
-		// Force re-initialization by clearing service instances
-		// This ensures a clean slate even if state update failed
-		this._configManager = undefined
-		this._serviceFactory = undefined
-		this._orchestrator = undefined
-		this._searchService = undefined
 	}
 
 	/**