import { safeWriteJson } from "../../utils/safeWriteJson" import * as path from "path" import * as os from "os" import * as fs from "fs/promises" import { getRooDirectoriesForCwd } from "../../services/roo-config/index.js" import pWaitFor from "p-wait-for" import * as vscode from "vscode" import { type Language, type GlobalState, type ClineMessage, type TelemetrySetting, type ModelRecord, type ProviderSettings, type Command as SlashCommand, type WebviewMessage, type EditQueuedMessagePayload, TelemetryEventName, RooCodeSettings, ExperimentId, checkoutDiffPayloadSchema, checkoutRestorePayloadSchema, getCompletionCheckpoint, providerIdentifiers, retiredProviderIdentifiers, LmStudioModelsMessageType, OllamaModelsMessageType, OpenAiModelsMessageType, RouterModelsMessageType, VsCodeLmModelsMessageType, isTelemetryOptedIn, } from "@roo-code/types" import { handleRequestProviderInfo } from "./providerInfoHandler" import { customToolRegistry } from "@roo-code/core" import { CloudService } from "@roo-code/cloud" import { TelemetryService } from "@roo-code/telemetry" import { type ApiMessage } from "../task-persistence/apiMessages" import { saveTaskMessages } from "../task-persistence" import { isInvalidDisplayValue } from "../config/displaySettings" import { ProviderSettingsNotFoundError } from "../config/ProviderSettingsManager" import { importRooTaskHistory } from "../task-persistence/importRooTaskHistory" import { ClineProvider } from "./ClineProvider" import { findOriginalContent } from "./stripOriginalContent" import { handleCheckpointRestoreOperation } from "./checkpointRestoreHandler" import { assertRecordedCheckpoint } from "../checkpoints/recordedCheckpoint" import { generateErrorDiagnostics } from "./diagnosticsHandler" import { handleRequestSkills, handleCreateSkill, handleDeleteSkill, handleMoveSkill, handleUpdateSkillModes, handleOpenSkillFile, } from "./skillsMessageHandler" import { handleRequestRules, handleCreateRule, handleDeleteRule, handleOpenRuleFile, handleOpenRulesDirectory, } from "./rulesMessageHandler" import { changeLanguage, t } from "../../i18n" import { Package } from "../../shared/package" import { type RouterName, toRouterName } from "../../shared/api" import { MessageEnhancer } from "./messageEnhancer" import { CodeIndexManagerRegistry } from "../../services/code-index/code-index-manager-registry" import { checkExistKey } from "../../shared/checkExistApiConfig" import { getRouterRemovalMessage, getRouterUnavailableSignInMessage } from "../config/routerRemoval" import { experimentDefault } from "../../shared/experiments" import { Terminal } from "../../integrations/terminal/Terminal" import { TerminalRegistry } from "../../integrations/terminal/TerminalRegistry" import { openFile } from "../../integrations/misc/open-file" import { openImage, saveImage } from "../../integrations/misc/image-handler" import { selectImages } from "../../integrations/misc/process-images" import { getTheme } from "../../integrations/theme/getTheme" import { searchWorkspaceFiles } from "../../services/search/file-search" import { fileExistsAtPath } from "../../utils/fs" import { playTts, setTtsEnabled, setTtsSpeed, stopTts } from "../../utils/tts" import { searchCommits } from "../../utils/git" import { exportSettings, importSettingsWithFeedback } from "../config/importExport" import { getOpenAiModels } from "../../api/providers/openai" import { getVsCodeLmModels } from "../../api/providers/vscode-lm" import { getGitHubCopilotViewState } from "../../services/language-models/copilotViewState" import { connectGitHubCopilot, getGitHubCopilotAccount, getGitHubCopilotModels, openGitHubAccountManagement, } from "../../api/providers/github-copilot" import { openMention } from "../mentions" import { resolveImageMentions } from "../mentions/resolveImageMentions" import { RooIgnoreController } from "../ignore/RooIgnoreController" import { getWorkspacePath } from "../../utils/path" import { isPathOutsideWorkspace, decodeUntrustedPathToStable, isRealPathOutsideWorkspace } from "../../utils/pathUtils" import { Mode, defaultModeSlug } from "../../shared/modes" import { buildApiHandler, type ApiHandler } from "../../api" import { getModels, flushModels } from "../../api/providers/fetchers/modelCache" import { GetModelsOptions } from "../../shared/api" import { generateSystemPrompt } from "./generateSystemPrompt" import { resolveDefaultSaveUri, saveLastExportPath } from "../../utils/export" import { getCommand } from "../../utils/commands" import { getLMStudioModels } from "../../api/providers/fetchers/lmstudio" const ALLOWED_VSCODE_SETTINGS = new Set(["terminal.integrated.inheritEnv"]) // Serializes handling of "telemetrySetting" messages. Each invocation reads the previous // setting, awaits a persistence write, then applies the new live telemetry state -- with no // serialization, two rapid messages (e.g. a fast toggle) can interleave across those awaits: // each invocation captures its own isOptedIn in a closure, so whichever invocation's tail end // (TelemetryService.instance.updateTelemetryState) happens to resolve *last* wins, regardless // of which message the user sent last. Chaining onto this promise ensures a given invocation's // entire read-write-apply sequence completes before the next one starts. let telemetrySettingQueue: Promise = Promise.resolve() import { MarketplaceManager, MarketplaceItemType } from "../../services/marketplace" import { setPendingTodoList } from "../tools/UpdateTodoListTool" import { handleListWorktrees, handleCreateWorktree, handleDeleteWorktree, handleSwitchWorktree, handleGetAvailableBranches, handleGetWorktreeDefaults, handleGetWorktreeIncludeStatus, handleCheckBranchWorktreeInclude, handleCreateWorktreeInclude, handleCheckoutBranch, } from "./worktree" const handlerFor = (apiConfiguration: ProviderSettings, provider: RouterName): ApiHandler => buildApiHandler({ ...apiConfiguration, apiProvider: provider }) export const webviewMessageHandler = async ( provider: ClineProvider, message: WebviewMessage, marketplaceManager?: MarketplaceManager, ) => { // Utility functions provided for concise get/update of global state via contextProxy API. const getGlobalState = (key: K) => provider.contextProxy.getValue(key) const updateGlobalState = async (key: K, value: GlobalState[K]) => await provider.contextProxy.setValue(key, value) const getCurrentCwd = () => { return provider.getCurrentTask()?.cwd || provider.cwd } const isCloudServiceAvailable = () => CloudService.hasInstance() const showCloudUnavailableMessage = () => { vscode.window.showInformationMessage(getRouterUnavailableSignInMessage()) } const resolveCompletionCheckpoint = (currentCline: { clineMessages: ClineMessage[] }) => { return getCompletionCheckpoint(currentCline.clineMessages) } const getCurrentMode = async (): Promise => { const currentTask = provider.getCurrentTask() if (currentTask) { try { return await currentTask.getTaskMode() } catch (error) { provider.log( `Error resolving current task mode for command discovery: ${JSON.stringify(error, Object.getOwnPropertyNames(error), 2)}`, ) } } try { const state = await provider.getState() if (typeof state.mode === "string" && state.mode.length > 0) { return state.mode } } catch (error) { provider.log( `Error resolving global mode for command discovery: ${JSON.stringify(error, Object.getOwnPropertyNames(error), 2)}`, ) } return defaultModeSlug } const getDiscoveredCommands = async (): Promise => { const { getCommands } = await import("../../services/command/commands") const commands = await getCommands(getCurrentCwd()) const commandList: SlashCommand[] = commands.map((command) => ({ name: command.name, source: command.source, filePath: command.filePath, description: command.description, argumentHint: command.argumentHint, })) const existingCommandNames = new Set(commandList.map((command) => command.name)) const skillsManager = provider.getSkillsManager() if (!skillsManager) { return commandList } const currentMode = await getCurrentMode() const availableSkills = skillsManager.getSkillsForMode(currentMode) for (const skill of availableSkills) { if (existingCommandNames.has(skill.name)) { continue } existingCommandNames.add(skill.name) commandList.push({ name: skill.name, source: skill.source, filePath: skill.path, description: skill.description, }) } return commandList } /** * Resolves image file mentions in incoming messages. * Matches read_file behavior: respects size limits and model capabilities. */ const resolveIncomingImages = async (payload: { text?: string; images?: string[] }) => { const text = payload.text ?? "" const images = payload.images const currentTask = provider.getCurrentTask() const state = await provider.getState() const resolved = await resolveImageMentions({ text, images, cwd: getCurrentCwd(), rooIgnoreController: currentTask?.rooIgnoreController, maxImageFileSize: state.maxImageFileSize, maxTotalImageSize: state.maxTotalImageSize, }) return resolved } /** * Shared utility to find message indices based on timestamp. * When multiple messages share the same timestamp (e.g., after condense), * this function prefers non-summary messages to ensure user operations * target the intended message rather than the summary. */ const findMessageIndices = (messageTs: number, currentCline: any) => { // Find the exact message by timestamp, not the first one after a cutoff const messageIndex = currentCline.clineMessages.findIndex((msg: ClineMessage) => msg.ts === messageTs) // Find all matching API messages by timestamp const allApiMatches = currentCline.apiConversationHistory .map((msg: ApiMessage, idx: number) => ({ msg, idx })) .filter(({ msg }: { msg: ApiMessage }) => msg.ts === messageTs) // Prefer non-summary message if multiple matches exist (handles timestamp collision after condense) const preferred = allApiMatches.find(({ msg }: { msg: ApiMessage }) => !msg.isSummary) || allApiMatches[0] const apiConversationHistoryIndex = preferred?.idx ?? -1 return { messageIndex, apiConversationHistoryIndex } } /** * Fallback: find first API history index at or after a timestamp. * Used when the exact user message isn't present in apiConversationHistory (e.g., after condense). */ const findFirstApiIndexAtOrAfter = (ts: number, currentCline: any) => { if (typeof ts !== "number") return -1 return currentCline.apiConversationHistory.findIndex( (msg: ApiMessage) => typeof msg?.ts === "number" && (msg.ts as number) >= ts, ) } /** * Handles message deletion operations with user confirmation */ const handleDeleteOperation = async (messageTs: number): Promise => { // Check if there's a checkpoint before this message const currentCline = provider.getCurrentTask() let hasCheckpoint = false if (!currentCline) { await vscode.window.showErrorMessage(t("common:errors.message.no_active_task_to_delete")) return } const { messageIndex } = findMessageIndices(messageTs, currentCline) if (messageIndex !== -1) { // Find the last checkpoint before this message const checkpoints = currentCline.clineMessages.filter( (msg) => msg.say === "checkpoint_saved" && msg.ts > messageTs, ) hasCheckpoint = checkpoints.length > 0 } // Send message to webview to show delete confirmation dialog await provider.postMessageToWebview({ type: "showDeleteMessageDialog", messageTs, hasCheckpoint, }) } /** * Handles confirmed message deletion from webview dialog */ const handleDeleteMessageConfirm = async (messageTs: number, restoreCheckpoint?: boolean): Promise => { const currentCline = provider.getCurrentTask() if (!currentCline) { console.error("[handleDeleteMessageConfirm] No current cline available") return } const { messageIndex, apiConversationHistoryIndex } = findMessageIndices(messageTs, currentCline) // Determine API truncation index with timestamp fallback if exact match not found let apiIndexToUse = apiConversationHistoryIndex const tsThreshold = currentCline.clineMessages[messageIndex]?.ts if (apiIndexToUse === -1 && typeof tsThreshold === "number") { apiIndexToUse = findFirstApiIndexAtOrAfter(tsThreshold, currentCline) } if (messageIndex === -1) { await vscode.window.showErrorMessage(t("common:errors.message.message_not_found", { messageTs })) return } try { const targetMessage = currentCline.clineMessages[messageIndex] // If checkpoint restoration is requested, find and restore to the last checkpoint before this message if (restoreCheckpoint) { // Find the last checkpoint before this message const checkpoints = currentCline.clineMessages.filter( (msg) => msg.say === "checkpoint_saved" && msg.ts > messageTs, ) const nextCheckpoint = checkpoints[0] if (nextCheckpoint && nextCheckpoint.text) { await handleCheckpointRestoreOperation({ provider, currentCline, messageTs: targetMessage.ts!, messageIndex, checkpoint: { hash: nextCheckpoint.text }, operation: "delete", }) } else { // No checkpoint found before this message console.log("[handleDeleteMessageConfirm] No checkpoint found before message") vscode.window.showWarningMessage("No checkpoint found before this message") } } else { // For non-checkpoint deletes, preserve checkpoint associations for remaining messages // Store checkpoints from messages that will be preserved const preservedCheckpoints = new Map() for (let i = 0; i < messageIndex; i++) { const msg = currentCline.clineMessages[i] if (msg?.checkpoint && msg.ts) { preservedCheckpoints.set(msg.ts, msg.checkpoint) } } // Delete this message and all subsequent messages using MessageManager await currentCline.messageManager.rewindToTimestamp(targetMessage.ts!, { includeTargetMessage: false }) // Restore checkpoint associations for preserved messages for (const [ts, checkpoint] of preservedCheckpoints) { const msgIndex = currentCline.clineMessages.findIndex((msg) => msg.ts === ts) if (msgIndex !== -1) { currentCline.clineMessages[msgIndex].checkpoint = checkpoint } } // Save the updated messages with restored checkpoints await saveTaskMessages({ messages: currentCline.clineMessages, taskId: currentCline.taskId, globalStoragePath: provider.contextProxy.globalStorageUri.fsPath, }) // Update the UI to reflect the deletion await provider.postStateToWebview() } } catch (error) { console.error("Error in delete message:", error) vscode.window.showErrorMessage( t("common:errors.message.error_deleting_message", { error: error instanceof Error ? error.message : String(error), }), ) } } /** * Handles message editing operations with user confirmation */ const handleEditOperation = async (messageTs: number, editedContent: string, images?: string[]): Promise => { // Check if there's a checkpoint before this message const currentCline = provider.getCurrentTask() let hasCheckpoint = false if (currentCline) { const { messageIndex } = findMessageIndices(messageTs, currentCline) if (messageIndex !== -1) { // Find the last checkpoint before this message const checkpoints = currentCline.clineMessages.filter( (msg) => msg.say === "checkpoint_saved" && msg.ts > messageTs, ) hasCheckpoint = checkpoints.length > 0 } else { console.log("[webviewMessageHandler] Edit - Message not found in clineMessages!") } } else { console.log("[webviewMessageHandler] Edit - No currentCline available!") } // Send message to webview to show edit confirmation dialog await provider.postMessageToWebview({ type: "showEditMessageDialog", messageTs, text: editedContent, hasCheckpoint, images, }) } /** * Handles confirmed message editing from webview dialog */ const handleEditMessageConfirm = async ( messageTs: number, editedContent: string, restoreCheckpoint?: boolean, images?: string[], ): Promise => { const currentCline = provider.getCurrentTask() if (!currentCline) { console.error("[handleEditMessageConfirm] No current cline available") return } // Use findMessageIndices to find messages based on timestamp const { messageIndex, apiConversationHistoryIndex } = findMessageIndices(messageTs, currentCline) if (messageIndex === -1) { const errorMessage = t("common:errors.message.message_not_found", { messageTs }) console.error("[handleEditMessageConfirm]", errorMessage) await vscode.window.showErrorMessage(errorMessage) return } try { const targetMessage = currentCline.clineMessages[messageIndex] // If checkpoint restoration is requested, find and restore to the last checkpoint before this message if (restoreCheckpoint) { // Find the last checkpoint before this message const checkpoints = currentCline.clineMessages.filter( (msg) => msg.say === "checkpoint_saved" && msg.ts > messageTs, ) const nextCheckpoint = checkpoints[0] if (nextCheckpoint && nextCheckpoint.text) { await handleCheckpointRestoreOperation({ provider, currentCline, messageTs: targetMessage.ts!, messageIndex, checkpoint: { hash: nextCheckpoint.text }, operation: "edit", editData: { editedContent, images, apiConversationHistoryIndex, }, }) // The task will be cancelled and reinitialized by checkpointRestore // The pending edit will be processed in the reinitialized task return } else { // No checkpoint found before this message console.log("[handleEditMessageConfirm] No checkpoint found before message") vscode.window.showWarningMessage("No checkpoint found before this message") // Continue with non-checkpoint edit } } // For non-checkpoint edits, remove the ORIGINAL user message being edited and all subsequent messages // Determine the correct starting index to delete from (prefer the last preceding user_feedback message) let deleteFromMessageIndex = messageIndex let deleteFromApiIndex = apiConversationHistoryIndex // Find the nearest preceding user message to ensure we replace the original, not just the assistant reply for (let i = messageIndex; i >= 0; i--) { const m = currentCline.clineMessages[i] if (m?.say === "user_feedback") { deleteFromMessageIndex = i // Align API history truncation to the same user message timestamp if present const userTs = m.ts if (typeof userTs === "number") { const apiIdx = currentCline.apiConversationHistory.findIndex( (am: ApiMessage) => am.ts === userTs, ) if (apiIdx !== -1) { deleteFromApiIndex = apiIdx } } break } } // Timestamp fallback for API history when exact user message isn't present if (deleteFromApiIndex === -1) { const tsThresholdForEdit = currentCline.clineMessages[deleteFromMessageIndex]?.ts if (typeof tsThresholdForEdit === "number") { deleteFromApiIndex = findFirstApiIndexAtOrAfter(tsThresholdForEdit, currentCline) } } // Store checkpoints from messages that will be preserved const preservedCheckpoints = new Map() for (let i = 0; i < deleteFromMessageIndex; i++) { const msg = currentCline.clineMessages[i] if (msg?.checkpoint && msg.ts) { preservedCheckpoints.set(msg.ts, msg.checkpoint) } } // Delete the original (user) message and all subsequent messages using MessageManager const rewindTs = currentCline.clineMessages[deleteFromMessageIndex]?.ts if (rewindTs) { await currentCline.messageManager.rewindToTimestamp(rewindTs, { includeTargetMessage: false }) } // Restore checkpoint associations for preserved messages for (const [ts, checkpoint] of preservedCheckpoints) { const msgIndex = currentCline.clineMessages.findIndex((msg) => msg.ts === ts) if (msgIndex !== -1) { currentCline.clineMessages[msgIndex].checkpoint = checkpoint } } // Save the updated messages with restored checkpoints await saveTaskMessages({ messages: currentCline.clineMessages, taskId: currentCline.taskId, globalStoragePath: provider.contextProxy.globalStorageUri.fsPath, }) // Update the UI to reflect the deletion await provider.postStateToWebview() await currentCline.submitUserMessage(editedContent, images) } catch (error) { console.error("Error in edit message:", error) vscode.window.showErrorMessage( t("common:errors.message.error_editing_message", { error: error instanceof Error ? error.message : String(error), }), ) } } /** * Handles message modification operations (delete or edit) with confirmation dialog * @param messageTs Timestamp of the message to operate on * @param operation Type of operation ('delete' or 'edit') * @param editedContent New content for edit operations * @returns Promise */ const handleMessageModificationsOperation = async ( messageTs: number, operation: "delete" | "edit", editedContent?: string, images?: string[], ): Promise => { if (operation === "delete") { await handleDeleteOperation(messageTs) } else if (operation === "edit" && editedContent) { await handleEditOperation(messageTs, editedContent, images) } } switch (message.type) { case "themeFixtureProbeResponse": if (process.env.ROO_CODE_THEME_FIXTURE_PROBE === "1" && message.requestId && message.themeFixture) { provider.resolveWebviewThemeFixtureProbe(message.requestId, message.themeFixture) } break case "webviewDidLaunch": { // Launch repair, run inside the view-state readiness window: a pin that names // a removed profile is re-pointed here, and a task created before this ran // would record the removed profile name in its own task record. const repairRemovedViewPin = async () => { try { const listApiConfig = await provider.providerSettingsManager.listConfig() if (!listApiConfig) { return } if (listApiConfig.length === 1) { // Check if first time init then sync with exist config. if (!checkExistKey(listApiConfig[0])) { const { apiConfiguration } = await provider.getState() // Only save if the current configuration has meaningful settings // (e.g., API keys). This prevents saving a default "anthropic" // fallback when no real config exists, which can happen during // CLI initialization before provider settings are applied. if (checkExistKey(apiConfiguration)) { await provider.providerSettingsManager.saveConfig( listApiConfig[0].name ?? "default", apiConfiguration, ) listApiConfig[0].apiProvider = apiConfiguration.apiProvider } } } const currentState = await provider.getState() const currentConfigName = currentState.currentApiConfigName if (currentConfigName) { if (!(await provider.providerSettingsManager.hasConfig(currentConfigName))) { // The merged name (which may be this view's durable pin) no longer // resolves. When the shared global selection is still valid, re-pin // only this view so the global selection is left untouched; only // repair the global when it is invalid as well. const globalConfigName = getGlobalState("currentApiConfigName") const globalStillValid = !!globalConfigName && (await provider.providerSettingsManager.hasConfig(globalConfigName)) const name = listApiConfig[0]?.name if (globalStillValid && globalConfigName) { // Re-pin this view to the still-valid shared global selection (not the // first listed profile) through the activation path so the view adopts // the shared choice's settings: a name-only re-pin would leave the // invalid profile's stale apiConfiguration in place. The activation // writes the shared slot back with the same value, so the global // selection itself is left untouched, and the first listed profile's // name (absent on legacy shapes) is irrelevant to this branch. // Skip both persistence steps: this is a launch-time repair of this // view's own selection, and persisting would silently rewrite the // current mode's saved profile (setModeConfig) and the task's sticky // profile, which every other view reads. Also leave a current task that follows // a different sticky profile alone: this repair must not swap that task's API // handler (preserveForeignTask). await provider.activateProviderProfile( { name: globalConfigName }, { persistModeConfig: false, persistTaskHistory: false, preserveForeignTask: true, }, ) // Fall through: refresh listApiConfigMeta and post listApiConfig // to this webview below. } else { // Current config name not valid, get first config in list. await updateGlobalState("currentApiConfigName", name) if (name) { await provider.activateProviderProfile({ name }) return } } } } await Promise.all([ await updateGlobalState("listApiConfigMeta", listApiConfig), await provider.postMessageToWebview({ type: "listApiConfig", listApiConfig }), ]) } catch (error) { provider.log( `Error list api configuration: ${JSON.stringify(error, Object.getOwnPropertyNames(error), 2)}`, ) // The repair runs inside the view-state readiness window: swallowing the failure // here resolves readiness while this view is still pinned to a profile that no // longer exists, so an API-created task records the removed name. The failure must // reach setViewStateId, which restores the previous id and leaves readiness pending. throw error } } // A failed view-state registration must not abort launch handling: the // initial state, theme and API-configuration sync below still run, and the // provider restores its previous viewStateId on failure (setViewStateId) so // a later launch retries registration and loadViewState instead of // treating the failed id as already handled. let repairRanInsideRegistration = false let registrationFailed = false try { await provider.setViewStateId(message.viewStateId, async () => { repairRanInsideRegistration = true await repairRemovedViewPin() }) } catch (error) { registrationFailed = true provider.log( `[webviewDidLaunch] view-state registration failed: ${error instanceof Error ? error.message : String(error)}`, ) } if (registrationFailed || !repairRanInsideRegistration) { // Either registration failed - this view's state was never loaded - or // setViewStateId returned early without reaching the repair: an unusable id, // this view's id again (a reload keeps the same id), or an id another live // view already owns. The launch repair still has to run in every one of those // cases, or a pin that names a removed profile survives the launch. It can fail // for the same reason registration did, so its own failure is logged and // contained here instead of aborting the rest of launch handling. try { await repairRemovedViewPin() } catch (repairError) { provider.log( `[webviewDidLaunch] launch repair failed${registrationFailed ? " after registration failure" : ""}: ${ repairError instanceof Error ? repairError.message : String(repairError) }`, ) } } // Load custom modes first const customModes = await provider.customModesManager.getCustomModes() await updateGlobalState("customModes", customModes) await provider.postStateToWebview() void provider.workspaceTracker ?.initializeFilePaths() .catch((err) => provider.log(`Workspace initialization error: ${err}`)) // Don't await. await getTheme().then((theme) => provider.postMessageToWebview({ type: "theme", text: JSON.stringify(theme) }), ) // If MCP Hub is already initialized, update the webview with // current server list. const mcpHub = provider.getMcpHub() if (mcpHub) { await provider.postMessageToWebview({ type: "mcpServers", mcpServers: mcpHub.getAllServers() }) } // Telemetry is on by disclosed default: "unset" (no choice made yet) leaves that // default in effect, same as "enabled". Only an explicit "disabled" opts out. // vscode.env.isTelemetryEnabled is ANDed in (matching extension.ts's // onDidChangeTelemetryEnabled listener) so a webview reload can't re-enable // telemetry while VS Code's global toggle is off. // // Read the setting synchronously via getGlobalState (same as the "telemetrySetting" // handler below) rather than awaiting provider.getStateToPostToWebview() -- that // async gap let this continuation resolve after a concurrent "telemetrySetting" // message's queued update and clobber it with a stale value, the same interleaving // class of bug telemetrySettingQueue exists to prevent. Routing through the queue // here too means webviewDidLaunch can't race a concurrent telemetrySetting message // either. telemetrySettingQueue = telemetrySettingQueue .catch(() => undefined) .then(async () => { if (!TelemetryService.hasInstance()) { return } const telemetrySetting = getGlobalState("telemetrySetting") || "unset" TelemetryService.instance.updateTelemetryState( isTelemetryOptedIn(telemetrySetting) && vscode.env.isTelemetryEnabled, ) }) await telemetrySettingQueue.catch((error) => provider.log( `Error initializing telemetry state on launch: ${error instanceof Error ? error.message : String(error)}`, ), ) provider.isViewLaunched = true break } case "webviewHeartbeat": // Confirm renderer liveness and advance the watchdog recovery health window. provider.updateWebviewHeartbeat() break case "newTask": // Initializing new instance of Cline will make sure that any // agentically running promises in old instance don't affect our new // task. This essentially creates a fresh slate for the new task. try { const resolved = await resolveIncomingImages({ text: message.text, images: message.images }) await provider.createTask( resolved.text, resolved.images, undefined, { taskId: message.taskId }, message.taskConfiguration, ) // Task created successfully - notify the UI to reset await provider.postMessageToWebview({ type: "invoke", invoke: "newChat" }) } catch (error) { // For all errors, reset the UI and show error await provider.postMessageToWebview({ type: "invoke", invoke: "newChat" }) // Show error to user vscode.window.showErrorMessage( `Failed to create task: ${error instanceof Error ? error.message : String(error)}`, ) } break case "customInstructions": await provider.updateCustomInstructions(message.text) break case "askResponse": { const resolved = await resolveIncomingImages({ text: message.text, images: message.images }) provider .getCurrentTask() ?.handleWebviewAskResponse(message.askResponse!, resolved.text, resolved.images) } break case "updateSettings": { // The settings are written one at a time, in the order sent, and not as a transaction. If a write fails, the // ones before it stay stored and the ones after it are not written. The display settings only change how // times are shown, so a partial save is harmless, and saving again completes it. Either way the webview is // refreshed and, if the request has an id, told whether the save was stored (`settingsSaveResult`): the // settings page keeps the user's edits as unsaved after a failure. The error is then thrown, as it always was. let failed = false let failure: unknown try { if (!message.updatedSettings) break if (message.updatedSettings.destructiveCommandGuardEnabled === true) { try { const { ensureDcgInstalled } = await import("../../services/destructive-command-guard") const binaryPath = await ensureDcgInstalled(provider.context.globalStorageUri.fsPath) if (!binaryPath) { message.updatedSettings.destructiveCommandGuardEnabled = false vscode.window.showErrorMessage(t("common:errors.destructiveCommandGuard.unavailable")) } } catch (error) { message.updatedSettings.destructiveCommandGuardEnabled = false vscode.window.showErrorMessage( t("common:errors.destructiveCommandGuard.enableFailed", { error: error instanceof Error ? error.message : String(error), }), ) } } for (const [key, value] of Object.entries(message.updatedSettings)) { // An invalid display value is ignored, before anything is done for it. if (isInvalidDisplayValue(key, value)) { provider.log(`[updateSettings] Ignored an invalid value for ${key}`) continue } let newValue = value if (key === "language") { newValue = value ?? "en" changeLanguage(newValue as Language) } else if (key === "allowedCommands") { const commands = value ?? [] newValue = Array.isArray(commands) ? commands.filter((cmd) => typeof cmd === "string" && cmd.trim().length > 0) : [] await vscode.workspace .getConfiguration(Package.name) .update("allowedCommands", newValue, vscode.ConfigurationTarget.Global) } else if (key === "deniedCommands") { const commands = value ?? [] newValue = Array.isArray(commands) ? commands.filter((cmd) => typeof cmd === "string" && cmd.trim().length > 0) : [] await vscode.workspace .getConfiguration(Package.name) .update("deniedCommands", newValue, vscode.ConfigurationTarget.Global) } else if (key === "allowedReadFiles" || key === "allowedWriteFiles") { const patterns = value ?? [] // Blank lines, which the textarea editor produces freely, // name no file and are dropped here. Patterns are // otherwise not `.trim()`ed: leading whitespace is // significant in gitignore syntax, and trailing // whitespace has to be escaped by the user to be kept. newValue = Array.isArray(patterns) ? patterns.filter((pattern) => typeof pattern === "string" && pattern.trim().length > 0) : [] } else if (key === "ttsEnabled") { newValue = value ?? true setTtsEnabled(newValue as boolean) } else if (key === "ttsSpeed") { newValue = value ?? 1.0 setTtsSpeed(newValue as number) } else if (key === "terminalShellIntegrationTimeout") { if (value !== undefined) { Terminal.setShellIntegrationTimeout(value as number) } } else if (key === "terminalShellIntegrationDisabled") { if (value !== undefined) { Terminal.setShellIntegrationDisabled(value as boolean) } } else if (key === "terminalCommandDelay") { if (value !== undefined) { Terminal.setCommandDelay(value as number) } } else if (key === "terminalPowershellCounter") { if (value !== undefined) { Terminal.setPowershellCounter(value as boolean) } } else if (key === "terminalZshClearEolMark") { if (value !== undefined) { Terminal.setTerminalZshClearEolMark(value as boolean) } } else if (key === "terminalZshOhMy") { if (value !== undefined) { Terminal.setTerminalZshOhMy(value as boolean) } } else if (key === "terminalZshP10k") { if (value !== undefined) { Terminal.setTerminalZshP10k(value as boolean) } } else if (key === "terminalZdotdir") { if (value !== undefined) { Terminal.setTerminalZdotdir(value as boolean) } } else if (key === "terminalProfile") { const previousProfile = Terminal.getTerminalProfile() Terminal.setTerminalProfile(typeof value === "string" ? value : undefined) newValue = Terminal.getTerminalProfile() if (newValue !== previousProfile) { // Discard idle terminals so the next command gets a fresh // terminal using the new profile's shell instead of reusing // a stale one from the previous profile. TerminalRegistry.closeIdleTerminals() } } else if (key === "execaShellPath") { Terminal.setExecaShellPath(value as string | undefined) } else if (key === "mcpEnabled") { newValue = value ?? true const mcpHub = provider.getMcpHub() if (mcpHub) { await mcpHub.handleMcpEnabledChange(newValue as boolean) } } else if (key === "experiments") { if (!value) { continue } newValue = { ...(getGlobalState("experiments") ?? experimentDefault), ...(value as Record), } } else if (key === "customSupportPrompts") { if (!value) { continue } } // Route through provider.setValue so view-local buffer/pin sync stays // consistent with the other mutation paths. await provider.setValue(key as keyof RooCodeSettings, newValue) } } catch (error) { failed = true failure = error } // A failed refresh must neither undo a stored save nor keep the webview from getting the result. try { await provider.postStateToWebview() } catch (error) { provider.log( `[updateSettings] Could not refresh the webview state: ${error instanceof Error ? error.message : String(error)}`, ) } if (message.requestId) { await provider.postMessageToWebview({ type: "settingsSaveResult", requestId: message.requestId, success: !failed, ...(failed ? { error: failure instanceof Error ? failure.message : String(failure) } : {}), }) } if (failed) throw failure break } case "terminalOperation": if (message.terminalOperation) { await provider.getCurrentTask()?.handleTerminalOperation(message.terminalOperation) } break case "clearTask": // Clear task resets the current session. Delegation flows are // handled via metadata; parent resumption occurs through // reopenParentFromDelegation, not via finishSubTask. await provider.clearTask() await provider.postStateToWebview() break case "didShowAnnouncement": await updateGlobalState("lastShownAnnouncementId", provider.latestAnnouncementId) await provider.postStateToWebview() break case "selectImages": const images = await selectImages() await provider.postMessageToWebview({ type: "selectedImages", images, context: message.context, messageTs: message.messageTs, }) break case "exportCurrentTask": const currentTaskId = provider.getCurrentTask()?.taskId if (currentTaskId) { await provider.exportTaskWithId(currentTaskId) } break case "shareCurrentTask": const shareTaskId = provider.getCurrentTask()?.taskId if (!shareTaskId) { vscode.window.showErrorMessage(t("common:errors.share_no_active_task")) break } vscode.window.showErrorMessage(t("common:errors.share_not_enabled")) break case "showTaskWithId": await provider.showTaskWithId(message.text!) break case "condenseTaskContextRequest": await provider.condenseTaskContext(message.text!) break case "deleteTaskWithId": await provider.deleteTaskWithId(message.text!) break case "abandonSubtaskWithId": provider .abandonSubtask(message.text!) .catch((error) => provider.log( `[abandonSubtaskWithId] Failed: ${error instanceof Error ? error.message : String(error)}`, ), ) break case "deleteMultipleTasksWithIds": { const ids = message.ids if (Array.isArray(ids)) { // Process in batches of 20 (or another reasonable number) const batchSize = 20 const results = [] // Only log start and end of the operation console.log(`Batch deletion started: ${ids.length} tasks total`) for (let i = 0; i < ids.length; i += batchSize) { const batch = ids.slice(i, i + batchSize) const batchPromises = batch.map(async (id) => { try { await provider.deleteTaskWithId(id) return { id, success: true } } catch (error) { // Keep error logging for debugging purposes console.log( `Failed to delete task ${id}: ${error instanceof Error ? error.message : String(error)}`, ) return { id, success: false } } }) // Process each batch in parallel but wait for completion before starting the next batch const batchResults = await Promise.all(batchPromises) results.push(...batchResults) // Update the UI after each batch to show progress await provider.postStateToWebview() } // Log final results const successCount = results.filter((r) => r.success).length const failCount = results.length - successCount console.log( `Batch deletion completed: ${successCount}/${ids.length} tasks successful, ${failCount} tasks failed`, ) } break } case "exportTaskWithId": await provider.exportTaskWithId(message.text!) break case "renameTaskWithId": if (message.taskId) { await provider.renameTaskWithId(message.taskId, message.text) } break case "getTaskWithAggregatedCosts": { try { const taskId = message.text if (!taskId) { throw new Error("Task ID is required") } const result = await provider.getTaskWithAggregatedCosts(taskId) await provider.postMessageToWebview({ type: "taskWithAggregatedCosts", // IMPORTANT: ChatView stores aggregatedCostsMap keyed by message.text (taskId) // so we must include it here. text: taskId, historyItem: result.historyItem, aggregatedCosts: result.aggregatedCosts, }) } catch (error) { console.error("Error getting task with aggregated costs:", error) await provider.postMessageToWebview({ type: "taskWithAggregatedCosts", // Include taskId when available for correlation in UI logs. text: message.text, error: error instanceof Error ? error.message : String(error), }) } break } case "importSettings": { await importSettingsWithFeedback({ providerSettingsManager: provider.providerSettingsManager, contextProxy: provider.contextProxy, customModesManager: provider.customModesManager, provider: provider, }) break } case "importRooHistory": { let latestProgress = { copiedFileCount: 0, totalFileCount: 0, importedTaskCount: 0, totalTaskCount: 0, } try { await provider.postMessageToWebview({ type: "rooHistoryImportProgress", rooHistoryImportProgress: { status: "starting", ...latestProgress, }, }) const result = await importRooTaskHistory( provider.contextProxy.globalStorageUri.fsPath, async (progress) => { latestProgress = progress await provider.postMessageToWebview({ type: "rooHistoryImportProgress", rooHistoryImportProgress: { status: "copying", ...progress, }, }) }, ) if (result.foundTaskCount === 0) { await provider.postMessageToWebview({ type: "rooHistoryImportProgress", rooHistoryImportProgress: { status: "finished", ...latestProgress, }, }) vscode.window.showWarningMessage( t("common:warnings.rooHistoryImport.nothingFound", { domain: result.rooExtensionDomain }), ) break } // Refresh history whenever Roo tasks were found — even if all already existed — // so a retry after a partial-copy failure still reconciles the store. await provider.taskHistoryStore.invalidateAll() await provider.taskHistoryStore.reconcile() await provider.postStateToWebview() await provider.postMessageToWebview({ type: "rooHistoryImportProgress", rooHistoryImportProgress: { status: "finished", ...latestProgress, copiedFileCount: result.importedFileCount, totalFileCount: latestProgress.totalFileCount || result.importedFileCount, importedTaskCount: result.importedTaskCount, totalTaskCount: latestProgress.totalTaskCount || result.importedTaskCount, }, }) if (result.importedTaskCount === 0) { vscode.window.showWarningMessage( t("common:warnings.rooHistoryImport.alreadyImported", { count: result.foundTaskCount }), ) } else { vscode.window.showInformationMessage( t("common:info.rooHistoryImport.success", { count: result.importedTaskCount }), ) } } catch (error) { const message = error instanceof Error ? error.message : String(error) provider.log(`[importRooHistory] failed: ${message}`) await provider.postMessageToWebview({ type: "rooHistoryImportProgress", rooHistoryImportProgress: { status: "failed", ...latestProgress, }, }) vscode.window.showErrorMessage(t("common:errors.rooHistoryImport", { error: message })) } break } case "exportSettings": await exportSettings({ providerSettingsManager: provider.providerSettingsManager, contextProxy: provider.contextProxy, }) break case "resetState": await provider.resetState() break case "requestProviderInfo": await handleRequestProviderInfo(provider, message) break case RouterModelsMessageType.flushRouterModels: { const { apiConfiguration } = await provider.getState() const routerNameFlush: RouterName = toRouterName(message.text) // Note: flushRouterModels is a generic flush without credentials // For providers that need credentials, use their specific handlers await flushModels( { provider: routerNameFlush } as GetModelsOptions, handlerFor(apiConfiguration, routerNameFlush), true, ) break } case RouterModelsMessageType.requestRouterModels: { const { apiConfiguration } = await provider.getState() // Optional single provider filter from webview const requestedProvider = message?.values?.provider const providerFilter = requestedProvider ? toRouterName(requestedProvider) : undefined // Optional refresh flag to flush cache before fetching (useful for providers requiring credentials) const shouldRefresh = message?.values?.refresh === true const routerModels: Record = providerFilter ? ({} as Record) : { [providerIdentifiers.openrouter]: {}, [providerIdentifiers.vercelAiGateway]: {}, [providerIdentifiers.zooGateway]: {}, [providerIdentifiers.litellm]: {}, [providerIdentifiers.requesty]: {}, [providerIdentifiers.unbound]: {}, [providerIdentifiers.ollama]: {}, [providerIdentifiers.lmstudio]: {}, [providerIdentifiers.poe]: {}, [providerIdentifiers.deepseek]: {}, [providerIdentifiers.moonshot]: {}, [providerIdentifiers.opencodeGo]: {}, [providerIdentifiers.kenari]: {}, [providerIdentifiers.ioIntelligence]: {}, [providerIdentifiers.nanogpt]: {}, [providerIdentifiers.kimiCode]: {}, [providerIdentifiers.friendli]: {}, } const safeGetModels = async (options: GetModelsOptions, handler: ApiHandler): Promise => { try { return await getModels(options, handler) } catch (error) { console.error( `Failed to fetch models in webviewMessageHandler requestRouterModels for ${options.provider}:`, error, ) throw error // Re-throw to be caught by Promise.allSettled. } } // Base candidates (only those handled by this aggregate fetcher) const candidates: { key: RouterName; options: GetModelsOptions }[] = [ { key: providerIdentifiers.openrouter, options: { provider: providerIdentifiers.openrouter }, }, { key: providerIdentifiers.requesty, options: { provider: providerIdentifiers.requesty, apiKey: apiConfiguration.requestyApiKey, baseUrl: apiConfiguration.requestyBaseUrl, }, }, { key: providerIdentifiers.unbound, options: { provider: providerIdentifiers.unbound, apiKey: apiConfiguration.unboundApiKey, }, }, { key: providerIdentifiers.vercelAiGateway, options: { provider: providerIdentifiers.vercelAiGateway }, }, { key: providerIdentifiers.zooGateway, options: { provider: providerIdentifiers.zooGateway, apiKey: apiConfiguration.zooSessionToken, baseUrl: apiConfiguration.zooGatewayBaseUrl, }, }, ] // LiteLLM is conditional on baseUrl+apiKey. // Prefer explicit values from message (current unsaved field state) over saved config, // matching the pattern used for DeepSeek and other credential-carrying providers. const litellmApiKey = message?.values?.litellmApiKey ?? apiConfiguration.litellmApiKey const litellmBaseUrl = message?.values?.litellmBaseUrl ?? apiConfiguration.litellmBaseUrl if (litellmApiKey && litellmBaseUrl) { // If explicit credentials are provided in message.values (from Refresh Models button), // flush the cache first to ensure we fetch fresh data with the new credentials if (message?.values?.litellmApiKey || message?.values?.litellmBaseUrl) { await flushModels( { provider: providerIdentifiers.litellm, apiKey: litellmApiKey, baseUrl: litellmBaseUrl }, handlerFor(apiConfiguration, providerIdentifiers.litellm), true, ) } candidates.push({ key: providerIdentifiers.litellm, options: { provider: providerIdentifiers.litellm, apiKey: litellmApiKey, baseUrl: litellmBaseUrl }, }) } // Poe is conditional on apiKey const poeApiKey = apiConfiguration.poeApiKey || message?.values?.poeApiKey const poeBaseUrl = apiConfiguration.poeBaseUrl || message?.values?.poeBaseUrl if (poeApiKey) { if (message?.values?.poeApiKey || message?.values?.poeBaseUrl) { await flushModels( { provider: providerIdentifiers.poe, apiKey: poeApiKey, baseUrl: poeBaseUrl }, handlerFor(apiConfiguration, providerIdentifiers.poe), true, ) } candidates.push({ key: providerIdentifiers.poe, options: { provider: providerIdentifiers.poe, apiKey: poeApiKey, baseUrl: poeBaseUrl }, }) } // DeepSeek is conditional on apiKey const deepSeekApiKey = message?.values?.deepSeekApiKey ?? apiConfiguration.deepSeekApiKey const deepSeekBaseUrl = message?.values?.deepSeekBaseUrl ?? apiConfiguration.deepSeekBaseUrl if (deepSeekApiKey) { if (message?.values?.deepSeekApiKey || message?.values?.deepSeekBaseUrl) { await flushModels( { provider: providerIdentifiers.deepseek, apiKey: deepSeekApiKey, baseUrl: deepSeekBaseUrl }, handlerFor(apiConfiguration, providerIdentifiers.deepseek), true, ) } candidates.push({ key: providerIdentifiers.deepseek, options: { provider: providerIdentifiers.deepseek, apiKey: deepSeekApiKey, baseUrl: deepSeekBaseUrl, }, }) } // Moonshot is conditional on apiKey const moonshotApiKey = message?.values?.moonshotApiKey ?? apiConfiguration.moonshotApiKey const moonshotBaseUrl = message?.values?.moonshotBaseUrl ?? apiConfiguration.moonshotBaseUrl if (moonshotApiKey) { if (message?.values?.moonshotApiKey || message?.values?.moonshotBaseUrl) { await flushModels( { provider: providerIdentifiers.moonshot, apiKey: moonshotApiKey, baseUrl: moonshotBaseUrl }, handlerFor(apiConfiguration, providerIdentifiers.moonshot), true, ) } candidates.push({ key: providerIdentifiers.moonshot, options: { provider: providerIdentifiers.moonshot, apiKey: moonshotApiKey, baseUrl: moonshotBaseUrl, }, }) } // Opencode Go's /models endpoint is public — it returns the full model list with no // Authorization header — so it's fetched unconditionally like openrouter/vercel-ai-gateway // above. Gating it behind a key meant the picker stayed empty (and fell back to the default // model) whenever the key wasn't yet in apiConfiguration at fetch time. The key is still // forwarded when present. const opencodeGoApiKey = message?.values?.opencodeGoApiKey ?? apiConfiguration.opencodeGoApiKey // Refresh the cache when a new key is explicitly provided (e.g. the Refresh Models button). if (message?.values?.opencodeGoApiKey) { await flushModels( { provider: providerIdentifiers.opencodeGo, apiKey: opencodeGoApiKey }, handlerFor(apiConfiguration, providerIdentifiers.opencodeGo), true, ) } candidates.push({ key: providerIdentifiers.opencodeGo, options: { provider: providerIdentifiers.opencodeGo, apiKey: opencodeGoApiKey }, }) // Kenari's /models endpoint is public — it returns the full model list with no // Authorization header — so it's fetched unconditionally like openrouter/vercel-ai-gateway // above. Gating it behind a key meant the picker stayed empty (and fell back to the default // model) whenever the key wasn't yet in apiConfiguration at fetch time. The key is still // forwarded when present. const kenariApiKey = message?.values?.kenariApiKey ?? apiConfiguration.kenariApiKey // Refresh the cache when a new key is explicitly provided (e.g. the Refresh Models button). if (message?.values?.kenariApiKey) { await flushModels( { provider: providerIdentifiers.kenari, apiKey: kenariApiKey }, handlerFor(apiConfiguration, providerIdentifiers.kenari), true, ) } candidates.push({ key: providerIdentifiers.kenari, options: { provider: providerIdentifiers.kenari, apiKey: kenariApiKey }, }) // IO Intelligence's /models catalog is public; an optional key can scope // the visible model set. Prefer an explicitly supplied unsaved key. const ioIntelligenceApiKey = message?.values?.ioIntelligenceApiKey ?? apiConfiguration.ioIntelligenceApiKey if (message?.values?.ioIntelligenceApiKey !== undefined) { await flushModels( { provider: providerIdentifiers.ioIntelligence, apiKey: ioIntelligenceApiKey }, handlerFor(apiConfiguration, providerIdentifiers.ioIntelligence), true, ) } candidates.push({ key: providerIdentifiers.ioIntelligence, options: { provider: providerIdentifiers.ioIntelligence, apiKey: ioIntelligenceApiKey }, }) // NanoGPT's detailed catalog is public, while an optional key can expose a // different allowlist. Prefer an explicitly supplied unsaved key and use the // same key-scoped options for refresh and retrieval. const nanoGptApiKey = message?.values?.nanoGptApiKey ?? apiConfiguration.nanoGptApiKey if (message?.values?.nanoGptApiKey !== undefined) { await flushModels( { provider: providerIdentifiers.nanogpt, apiKey: nanoGptApiKey }, handlerFor(apiConfiguration, providerIdentifiers.nanogpt), true, ) } candidates.push({ key: providerIdentifiers.nanogpt, options: { provider: providerIdentifiers.nanogpt, apiKey: nanoGptApiKey }, }) // Friendli's /models catalog is public. candidates.push({ key: providerIdentifiers.friendli, options: { provider: providerIdentifiers.friendli } }) if (!providerFilter || providerFilter === providerIdentifiers.kimiCode) { const { kimiCodeOAuthManager } = await import("../../integrations/kimi-code/oauth") const kimiCodeAuthMethod = message?.values?.kimiCodeAuthMethod ?? apiConfiguration.kimiCodeAuthMethod ?? "oauth" const kimiCodeApiKey = kimiCodeAuthMethod === "api-key" ? (message?.values?.kimiCodeApiKey ?? apiConfiguration.kimiCodeApiKey) : await kimiCodeOAuthManager.getAccessToken() if (kimiCodeApiKey) { candidates.push({ key: providerIdentifiers.kimiCode, options: { provider: providerIdentifiers.kimiCode, apiKey: kimiCodeApiKey }, }) } } // Apply single provider filter if specified const modelFetchPromises = providerFilter ? candidates.filter(({ key }) => key === providerFilter) : candidates // If refresh flag is set and we have a specific provider, flush its cache first if (shouldRefresh && providerFilter && modelFetchPromises.length > 0) { const targetCandidate = modelFetchPromises[0] await flushModels(targetCandidate.options, handlerFor(apiConfiguration, targetCandidate.key), true) } const results = await Promise.allSettled( modelFetchPromises.map(async ({ key, options }) => { const models = await safeGetModels(options, handlerFor(apiConfiguration, key)) return { key, models } // The key is `ProviderName` here. }), ) results.forEach((result, index) => { const routerName = modelFetchPromises[index].key if (result.status === "fulfilled") { routerModels[routerName] = result.value.models // Ollama and LM Studio settings pages still need these events. They are not fetched here. } else { // Handle rejection: Post a specific error message for this provider. const errorMessage = result.reason instanceof Error ? result.reason.message : String(result.reason) console.error(`Error fetching models for ${routerName}:`, result.reason) routerModels[routerName] = {} // Ensure it's an empty object in the main routerModels message. void provider.postMessageToWebview({ type: RouterModelsMessageType.singleRouterModelFetchResponse, success: false, error: errorMessage, values: { provider: routerName }, }) } }) await provider.postMessageToWebview({ type: RouterModelsMessageType.routerModels, routerModels, values: providerFilter ? { provider: requestedProvider } : undefined, }) break } case OllamaModelsMessageType.requestOllamaModels: { // Specific handler for Ollama models only. const { apiConfiguration: ollamaApiConfig } = await provider.getState() // Prefer the baseUrl/apiKey from the message values (which reflect // the user's unsaved edits in the settings form) over the saved // state, so the refresh uses the URL the user is actually looking // at — not the stale one from before they started editing. const baseUrl = message.values?.baseUrl ?? ollamaApiConfig.ollamaBaseUrl const apiKey = message.values?.apiKey ?? ollamaApiConfig.ollamaApiKey const logBaseUrl = baseUrl || "http://localhost:11434" const ollamaOptions = { provider: providerIdentifiers.ollama, baseUrl, apiKey, } const handler = handlerFor(ollamaApiConfig, providerIdentifiers.ollama) try { // Refresh the cache before reading the models. Keep this error // separate from the read below so diagnostics identify which // cache operation failed. await flushModels(ollamaOptions, handler, true) } catch (error) { const errorMsg = error instanceof Error ? error.message : String(error) provider.log(`[requestOllamaModels] Failed to refresh model cache for ${logBaseUrl}: ${errorMsg}`) await provider.postMessageToWebview({ type: OllamaModelsMessageType.ollamaModels, ollamaModels: {}, error: errorMsg, }) break } try { const ollamaModels = await getModels(ollamaOptions, handler) // Always post a response so the webview refresh status can // transition out of "loading" — even when no models are found. await provider.postMessageToWebview({ type: OllamaModelsMessageType.ollamaModels, ollamaModels }) } catch (error) { const errorMsg = error instanceof Error ? error.message : String(error) provider.log(`[requestOllamaModels] Failed to read models for ${logBaseUrl}: ${errorMsg}`) await provider.postMessageToWebview({ type: OllamaModelsMessageType.ollamaModels, ollamaModels: {}, error: errorMsg, }) } break } case LmStudioModelsMessageType.requestLmStudioModels: { // Specific handler for LM Studio models only. const { apiConfiguration: lmStudioApiConfig } = await provider.getState() try { const requestedBaseUrl = message.values?.baseUrl const hasPreviewBaseUrl = typeof requestedBaseUrl === "string" let lmStudioModels: ModelRecord if (hasPreviewBaseUrl) { lmStudioModels = await getLMStudioModels(requestedBaseUrl) } else { const lmStudioOptions = { provider: providerIdentifiers.lmstudio, baseUrl: lmStudioApiConfig.lmStudioBaseUrl, } const handler = handlerFor(lmStudioApiConfig, providerIdentifiers.lmstudio) // Flush cache and refresh to ensure fresh models. await flushModels(lmStudioOptions, handler, true) lmStudioModels = await getModels(lmStudioOptions, handler) } if (Object.keys(lmStudioModels).length > 0) { await provider.postMessageToWebview({ type: LmStudioModelsMessageType.lmStudioModels, lmStudioModels: lmStudioModels, }) } } catch (error) { // Silently fail - user hasn't configured LM Studio yet. console.debug("LM Studio models fetch failed:", error) } break } case "requestRooModels": { await provider.postMessageToWebview({ type: RouterModelsMessageType.singleRouterModelFetchResponse, success: false, error: getRouterRemovalMessage(), values: { provider: retiredProviderIdentifiers.roo }, }) break } case OpenAiModelsMessageType.requestOpenAiModels: if (message?.values?.baseUrl && message?.values?.apiKey) { const openAiModels = await getOpenAiModels( message?.values?.baseUrl, message?.values?.apiKey, message?.values?.openAiHeaders, ) await provider.postMessageToWebview({ type: OpenAiModelsMessageType.openAiModels, openAiModels }) } break case VsCodeLmModelsMessageType.githubCopilotSignIn: case VsCodeLmModelsMessageType.githubCopilotReconnect: { // Plain sign-in and Reconnect run as separate attempts, so an older one can finish after a newer one. // Only the latest request may publish, or its account and model list would overwrite newer state. const viewState = getGitHubCopilotViewState(provider) const requestId = ++viewState.signInId viewState.changes++ const isLatest = () => viewState.signInId === requestId try { const { models, account } = await connectGitHubCopilot(async (githubCopilotAccount: string) => { if (!isLatest()) return await provider.postMessageToWebview({ type: VsCodeLmModelsMessageType.githubCopilotModels, githubCopilotAccount, }) }, message.type === VsCodeLmModelsMessageType.githubCopilotReconnect) if (!isLatest()) break await provider.postMessageToWebview({ type: VsCodeLmModelsMessageType.githubCopilotSignInResult, vsCodeLmModels: models, githubCopilotAccount: account, }) } catch (error) { if (!isLatest()) break await provider.postMessageToWebview({ type: VsCodeLmModelsMessageType.githubCopilotSignInResult, error: error instanceof Error ? error.message : String(error), }) } finally { if (isLatest()) viewState.changes++ } break } case VsCodeLmModelsMessageType.githubCopilotManageAccount: try { await openGitHubAccountManagement() } catch (error) { provider.log( `Could not open VS Code account management: ${error instanceof Error ? error.message : String(error)}`, ) } break case VsCodeLmModelsMessageType.requestVsCodeLmModels: { if (message.apiConfiguration?.apiProvider !== providerIdentifiers.githubCopilot) { const vsCodeLmModels = await getVsCodeLmModels() // TODO: Cache like we do for OpenRouter, etc? await provider.postMessageToWebview({ type: VsCodeLmModelsMessageType.vsCodeLmModels, vsCodeLmModels }) break } const viewState = getGitHubCopilotViewState(provider) const changesAtStart = viewState.changes const refreshId = ++viewState.refreshId const isOutOfDate = () => viewState.changes !== changesAtStart || viewState.refreshId !== refreshId try { const githubCopilotAccount = await getGitHubCopilotAccount() const vsCodeLmModels = await getGitHubCopilotModels() if (isOutOfDate()) break await provider.postMessageToWebview({ type: VsCodeLmModelsMessageType.githubCopilotModels, vsCodeLmModels, githubCopilotAccount: githubCopilotAccount ?? null, }) } catch (error) { if (isOutOfDate()) break await provider.postMessageToWebview({ type: VsCodeLmModelsMessageType.githubCopilotModels, error: error instanceof Error ? error.message : String(error), }) } break } case "openImage": await openImage(message.text!, { values: message.values }) break case "saveImage": if (message.dataUri) { const matches = message.dataUri.match(/^data:image\/([a-zA-Z]+);base64,(.+)$/) if (!matches) { // Let saveImage handle invalid URI error await saveImage(message.dataUri, vscode.Uri.file("")) break } const format = matches[1] const defaultFileName = `img_${Date.now()}.${format}` const defaultUri = await resolveDefaultSaveUri( provider.contextProxy, "lastImageSavePath", defaultFileName, { useWorkspace: false, fallbackDir: path.join(os.homedir(), "Downloads"), }, ) const savedUri = await saveImage(message.dataUri, defaultUri) if (savedUri) { await saveLastExportPath(provider.contextProxy, "lastImageSavePath", savedUri) } } break case "openFile": { const rawPath = message.text || "" if (!rawPath) { break } // Task markdown links are untrusted, so markdown-sourced openFile // requests (flagged by the webview with fromMarkdown) must resolve // inside the current workspace. First-party callers (modes, MCP, // slash-command settings) may legitimately open global config files // outside the workspace, so they keep the previous behavior. const fromMarkdown = message.values?.fromMarkdown === true const rejectOutsideWorkspace = () => { void vscode.window.showErrorMessage( t("common:errors.cannot_access_path", { path: rawPath, error: t("common:errors.path_outside_workspace"), }), ) } let filePath = rawPath // Markdown link targets are URL syntax: percent-decode to a fixed point // here, at the containment boundary. openFile decodes AFTER this check, // so a request like `%2e%2e/%2e%2e/.env` would otherwise pass // containment as a literal and escape only after that later decode. if (fromMarkdown) { const decoded = decodeUntrustedPathToStable(rawPath) if (decoded === null) { rejectOutsideWorkspace() break } filePath = decoded } if (!path.isAbsolute(filePath)) { const cwd = getCurrentCwd() if (!cwd) { void vscode.window.showErrorMessage( t("common:errors.could_not_open_file", { errorMessage: t("common:errors.no_workspace") }), ) break } filePath = path.resolve(cwd, filePath) } // Workspace-boundary validation (defense in depth): the webview already // rejects traversal in markdown anchors, but refuse any markdown path // that still resolves outside the workspace. if (fromMarkdown && isPathOutsideWorkspace(filePath)) { rejectOutsideWorkspace() break } // Lexical containment cannot see symlinks: a link inside a workspace // folder may resolve to a target outside the workspace. Re-check the // real filesystem path (failing closed) before opening. if (fromMarkdown && (await isRealPathOutsideWorkspace(filePath))) { rejectOutsideWorkspace() break } await openFile( filePath, message.values as { create?: boolean; content?: string; line?: number; fromMarkdown?: boolean }, ) break } case "readFileContent": { const relPath = message.text || "" if (!relPath) { await provider.postMessageToWebview({ type: "fileContent", fileContent: { path: relPath, content: null, error: "No path provided" }, }) break } try { const cwd = getCurrentCwd() if (!cwd) { await provider.postMessageToWebview({ type: "fileContent", fileContent: { path: relPath, content: null, error: "No workspace path available" }, }) break } const absPath = path.resolve(cwd, relPath) // Workspace-boundary validation: prevent path traversal attacks if (isPathOutsideWorkspace(absPath)) { await provider.postMessageToWebview({ type: "fileContent", fileContent: { path: relPath, content: null, error: "Path is outside workspace" }, }) break } const content = await fs.readFile(absPath, "utf-8") await provider.postMessageToWebview({ type: "fileContent", fileContent: { path: relPath, content } }) } catch (err) { const errorMsg = err instanceof Error ? err.message : String(err) await provider.postMessageToWebview({ type: "fileContent", fileContent: { path: relPath, content: null, error: errorMsg }, }) } break } case "readOriginalContent": { const ts = message.messageTs if (typeof ts !== "number") { break } const task = provider.getCurrentTask() // A request made for another task must not be answered from the current one. const isRequestedTask = message.taskId === undefined || message.taskId === task?.taskId const id = { messageId: message.messageId, ts } await provider.postMessageToWebview({ type: "originalContent", originalContentInfo: { ts, messageId: message.messageId, taskId: message.taskId, content: isRequestedTask ? findOriginalContent(task?.clineMessages, id) : null, }, }) break } case "openMention": await openMention(getCurrentCwd(), message.text) break case "openExternal": if (message.url) { vscode.env.openExternal(vscode.Uri.parse(message.url)) } break case "checkpointDiff": const result = checkoutDiffPayloadSchema.safeParse(message.payload) if (result.success) { await provider.getCurrentTask()?.checkpointDiff(result.data) } break case "checkpointRestore": { const result = checkoutRestorePayloadSchema.safeParse(message.payload) if (result.success) { try { const taskBeforeCancel = provider.getCurrentTask() // Reject a bad hash before cancelling, so the running task survives. if (taskBeforeCancel) { assertRecordedCheckpoint(taskBeforeCancel, result.data.commitHash) } await provider.cancelTask() try { await pWaitFor(() => provider.getCurrentTask()?.isInitialized === true, { timeout: 3_000 }) } catch { vscode.window.showErrorMessage(t("common:errors.checkpoint_timeout")) return } await provider.getCurrentTask()?.checkpointRestore(result.data) } catch (error) { console.error("[checkpointRestore] checkpointRestore failed:", error) void vscode.window.showErrorMessage( t("common:errors.checkpoint_restore_failed", { error: error instanceof Error ? error.message : String(error), }), ) } } break } case "completionCheckpointDiff": { const currentCline = provider.getCurrentTask() const checkpoint = currentCline ? resolveCompletionCheckpoint(currentCline) : undefined if (currentCline && checkpoint) { await currentCline.checkpointDiff({ ts: checkpoint.ts, commitHash: checkpoint.commitHash, mode: "to-current", }) } break } case "completionCheckpointRestore": { const currentCline = provider.getCurrentTask() const checkpoint = currentCline ? resolveCompletionCheckpoint(currentCline) : undefined if (currentCline && checkpoint) { const originalTaskId = currentCline.taskId await provider.cancelTask() try { await pWaitFor(() => provider.getCurrentTask()?.isInitialized === true, { timeout: 3_000 }) } catch { vscode.window.showErrorMessage(t("common:errors.checkpoint_timeout")) return } try { const restoredTask = provider.getCurrentTask() if (!restoredTask || restoredTask.taskId !== originalTaskId) { vscode.window.showErrorMessage(t("common:errors.checkpoint_failed")) return } await restoredTask.checkpointRestore({ ts: checkpoint.ts, commitHash: checkpoint.commitHash, mode: "restore", }) } catch (error) { console.error("[completionCheckpointRestore] checkpointRestore failed:", error) void vscode.window.showErrorMessage( t("common:errors.checkpoint_restore_failed", { error: error instanceof Error ? error.message : String(error), }), ) } } break } case "cancelTask": await provider.cancelTask() break case "cancelAutoApproval": // Cancel any pending auto-approval timeout for the current task provider.getCurrentTask()?.cancelAutoApprovalTimeout() break case "allowedCommands": { // Validate and sanitize the commands array const commands = message.commands ?? [] const validCommands = Array.isArray(commands) ? commands.filter((cmd) => typeof cmd === "string" && cmd.trim().length > 0) : [] await updateGlobalState("allowedCommands", validCommands) // Also update workspace settings. await vscode.workspace .getConfiguration(Package.name) .update("allowedCommands", validCommands, vscode.ConfigurationTarget.Global) break } case "deniedCommands": { // Validate and sanitize the commands array const commands = message.commands ?? [] const validCommands = Array.isArray(commands) ? commands.filter((cmd) => typeof cmd === "string" && cmd.trim().length > 0) : [] await updateGlobalState("deniedCommands", validCommands) // Also update workspace settings. await vscode.workspace .getConfiguration(Package.name) .update("deniedCommands", validCommands, vscode.ConfigurationTarget.Global) break } case "openCustomModesSettings": { const customModesFilePath = await provider.customModesManager.getCustomModesFilePath() if (customModesFilePath) { await openFile(customModesFilePath) } break } case "openTerminalProfilePicker": { // Open VS Code's native terminal profile picker so the user can set the // default shell without leaving VS Code's own settings UI. await vscode.commands.executeCommand("workbench.action.terminal.selectDefaultShell") break } case "openKeyboardShortcuts": { // Open VSCode keyboard shortcuts settings and optionally filter to show the Roo Code commands const searchQuery = message.text || "" if (searchQuery) { // Open with a search query pre-filled await vscode.commands.executeCommand("workbench.action.openGlobalKeybindings", searchQuery) } else { // Just open the keyboard shortcuts settings await vscode.commands.executeCommand("workbench.action.openGlobalKeybindings") } break } case "openMcpSettings": { const mcpSettingsFilePath = await provider.getMcpHub()?.getMcpSettingsFilePath() if (mcpSettingsFilePath) { await openFile(mcpSettingsFilePath) } break } case "openProjectMcpSettings": { if (!vscode.workspace.workspaceFolders?.length) { vscode.window.showErrorMessage(t("common:errors.no_workspace")) return } const workspaceFolder = getCurrentCwd() const rooDir = path.join(workspaceFolder, ".roo") const mcpPath = path.join(rooDir, "mcp.json") try { await fs.mkdir(rooDir, { recursive: true }) const exists = await fileExistsAtPath(mcpPath) if (!exists) { await safeWriteJson(mcpPath, { mcpServers: {} }, { prettyPrint: true }) } await openFile(mcpPath) } catch (error) { vscode.window.showErrorMessage(t("mcp:errors.create_json", { error: `${error}` })) } break } case "deleteMcpServer": { if (!message.serverName) { break } try { provider.log(`Attempting to delete MCP server: ${message.serverName}`) await provider.getMcpHub()?.deleteServer(message.serverName, message.source as "global" | "project") provider.log(`Successfully deleted MCP server: ${message.serverName}`) // Refresh the webview state await provider.postStateToWebview() } catch (error) { const errorMessage = error instanceof Error ? error.message : String(error) provider.log(`Failed to delete MCP server: ${errorMessage}`) // Error messages are already handled by McpHub.deleteServer } break } case "restartMcpServer": { try { await provider.getMcpHub()?.restartConnection(message.text!, message.source as "global" | "project") } catch (error) { provider.log( `Failed to retry connection for ${message.text}: ${JSON.stringify(error, Object.getOwnPropertyNames(error), 2)}`, ) } break } case "toggleToolAlwaysAllow": { try { await provider .getMcpHub() ?.toggleToolAlwaysAllow( message.serverName!, message.source as "global" | "project", message.toolName!, Boolean(message.alwaysAllow), ) } catch (error) { provider.log( `Failed to toggle auto-approve for tool ${message.toolName}: ${JSON.stringify(error, Object.getOwnPropertyNames(error), 2)}`, ) } break } case "toggleToolEnabledForPrompt": { try { await provider .getMcpHub() ?.toggleToolEnabledForPrompt( message.serverName!, message.source as "global" | "project", message.toolName!, Boolean(message.isEnabled), ) } catch (error) { provider.log( `Failed to toggle enabled for prompt for tool ${message.toolName}: ${JSON.stringify(error, Object.getOwnPropertyNames(error), 2)}`, ) } break } case "toggleMcpServer": { try { await provider .getMcpHub() ?.toggleServerDisabled( message.serverName!, message.disabled!, message.source as "global" | "project", ) } catch (error) { provider.log( `Failed to toggle MCP server ${message.serverName}: ${JSON.stringify(error, Object.getOwnPropertyNames(error), 2)}`, ) } break } case "taskSyncEnabled": provider.log("Ignoring taskSyncEnabled update because cloud task sync is disabled") break case "refreshAllMcpServers": { const mcpHub = provider.getMcpHub() if (mcpHub) { await mcpHub.refreshAllConnections() } break } case "ttsEnabled": const ttsEnabled = message.bool ?? true await updateGlobalState("ttsEnabled", ttsEnabled) setTtsEnabled(ttsEnabled) await provider.postStateToWebview() break case "ttsSpeed": const ttsSpeed = message.value ?? 1.0 await updateGlobalState("ttsSpeed", ttsSpeed) setTtsSpeed(ttsSpeed) await provider.postStateToWebview() break case "playTts": if (message.text) { void playTts(message.text, { onStart: () => provider.postMessageToWebview({ type: "ttsStart", text: message.text }), onStop: () => provider.postMessageToWebview({ type: "ttsStop", text: message.text }), }) } break case "stopTts": stopTts() break case "updateVSCodeSetting": { const { setting, value } = message if (setting !== undefined && value !== undefined) { if (ALLOWED_VSCODE_SETTINGS.has(setting)) { await vscode.workspace.getConfiguration().update(setting, value, true) } else { vscode.window.showErrorMessage(`Cannot update restricted VSCode setting: ${setting}`) } } break } case "getVSCodeSetting": const { setting } = message if (setting) { try { await provider.postMessageToWebview({ type: "vsCodeSetting", setting, value: vscode.workspace.getConfiguration().get(setting), }) } catch (error) { console.error(`Failed to get VSCode setting ${message.setting}:`, error) await provider.postMessageToWebview({ type: "vsCodeSetting", setting, error: `Failed to get setting: ${error.message}`, value: undefined, }) } } break case "requestTerminalProfiles": { // Allowlisted request: read VS Code's terminal profiles server-side and // return only the sanitized profile names. The terminal profile dropdown // only needs names, so this avoids routing it through the generic // `getVSCodeSetting` handler (which reads any key the webview supplies). // Only profiles with a resolvable `path` are returned — source-only // profiles (e.g. { source: "PowerShell" }) cannot be mapped to a shell // binary by an extension and would silently fall back to the default. try { await provider.postMessageToWebview({ type: "terminalProfiles", profiles: Terminal.getAvailableProfileNames(), }) } catch (error) { console.error("Failed to get terminal profiles:", error) await provider.postMessageToWebview({ type: "terminalProfiles", profiles: [] }) } break } case "mode": await provider.handleModeSwitch(message.text as Mode) break case "updatePrompt": if (message.promptMode && message.customPrompt !== undefined) { const existingPrompts = getGlobalState("customModePrompts") ?? {} const updatedPrompts = { ...existingPrompts, [message.promptMode]: message.customPrompt } await updateGlobalState("customModePrompts", updatedPrompts) const currentState = await provider.getStateToPostToWebview() const stateWithPrompts = { ...currentState, customModePrompts: updatedPrompts, hasOpenedModeSelector: currentState.hasOpenedModeSelector ?? false, } await provider.postMessageToWebview({ type: "state", state: stateWithPrompts }) if (TelemetryService.hasInstance()) { // Determine which setting was changed by comparing objects const oldPrompt = existingPrompts[message.promptMode] || {} const newPrompt = message.customPrompt const changedSettings = Object.keys(newPrompt).filter( (key) => JSON.stringify((oldPrompt as Record)[key]) !== JSON.stringify((newPrompt as Record)[key]), ) if (changedSettings.length > 0) { TelemetryService.instance.captureModeSettingChanged(changedSettings[0]) } } } break case "deleteMessage": { if (!provider.getCurrentTask()) { await vscode.window.showErrorMessage(t("common:errors.message.no_active_task_to_delete")) break } if (typeof message.value !== "number" || !message.value) { await vscode.window.showErrorMessage(t("common:errors.message.invalid_timestamp_for_deletion")) break } await handleMessageModificationsOperation(message.value, "delete") break } case "submitEditedMessage": { if ( provider.getCurrentTask() && typeof message.value === "number" && message.value && message.editedMessageContent ) { await handleMessageModificationsOperation( message.value, "edit", message.editedMessageContent, message.images, ) } break } case "hasOpenedModeSelector": await updateGlobalState("hasOpenedModeSelector", message.bool ?? true) await provider.postStateToWebview() break case "lockApiConfigAcrossModes": { const enabled = message.bool ?? false await provider.context.workspaceState.update("lockApiConfigAcrossModes", enabled) await provider.postStateToWebview() break } case "toggleApiConfigPin": if (message.text) { const currentPinned = getGlobalState("pinnedApiConfigs") ?? {} const updatedPinned: Record = { ...currentPinned } if (currentPinned[message.text]) { delete updatedPinned[message.text] } else { updatedPinned[message.text] = true } await updateGlobalState("pinnedApiConfigs", updatedPinned) await provider.postStateToWebview() } break case "enhancementApiConfigId": await updateGlobalState("enhancementApiConfigId", message.text) await provider.postStateToWebview() break case "autoApprovalEnabled": await updateGlobalState("autoApprovalEnabled", message.bool ?? false) await provider.postStateToWebview() break case "enhancePrompt": if (message.text) { try { const state = await provider.getState() const { apiConfiguration, customSupportPrompts, listApiConfigMeta = [], enhancementApiConfigId, includeTaskHistoryInEnhance, } = state const currentCline = provider.getCurrentTask() const result = await MessageEnhancer.enhanceMessage({ text: message.text, apiConfiguration, customSupportPrompts, listApiConfigMeta, enhancementApiConfigId, includeTaskHistoryInEnhance, currentClineMessages: currentCline?.clineMessages, providerSettingsManager: provider.providerSettingsManager, taskId: currentCline?.taskId, }) if (result.success && result.enhancedText) { MessageEnhancer.captureTelemetry(currentCline?.taskId, includeTaskHistoryInEnhance) await provider.postMessageToWebview({ type: "enhancedPrompt", text: result.enhancedText }) } else { throw new Error(result.error || "Unknown error") } } catch (error) { provider.log( `Error enhancing prompt: ${JSON.stringify(error, Object.getOwnPropertyNames(error), 2)}`, ) vscode.window.showErrorMessage(t("common:errors.enhance_prompt")) await provider.postMessageToWebview({ type: "enhancedPrompt" }) } } break case "getSystemPrompt": try { const systemPrompt = await generateSystemPrompt(provider, message) await provider.postMessageToWebview({ type: "systemPrompt", text: systemPrompt, mode: message.mode, }) } catch (error) { provider.log( `Error getting system prompt: ${JSON.stringify(error, Object.getOwnPropertyNames(error), 2)}`, ) vscode.window.showErrorMessage(t("common:errors.get_system_prompt")) } break case "copySystemPrompt": try { const systemPrompt = await generateSystemPrompt(provider, message) await vscode.env.clipboard.writeText(systemPrompt) await vscode.window.showInformationMessage(t("common:info.clipboard_copy")) } catch (error) { provider.log( `Error getting system prompt: ${JSON.stringify(error, Object.getOwnPropertyNames(error), 2)}`, ) vscode.window.showErrorMessage(t("common:errors.get_system_prompt")) } break case "searchCommits": { const cwd = getCurrentCwd() if (cwd) { try { const commits = await searchCommits(message.query || "", cwd) await provider.postMessageToWebview({ type: "commitSearchResults", commits, }) } catch (error) { provider.log( `Error searching commits: ${JSON.stringify(error, Object.getOwnPropertyNames(error), 2)}`, ) vscode.window.showErrorMessage(t("common:errors.search_commits")) } } break } case "searchFiles": { const workspacePath = getCurrentCwd() if (!workspacePath) { // Handle case where workspace path is not available await provider.postMessageToWebview({ type: "fileSearchResults", results: [], requestId: message.requestId, error: "No workspace path available", }) break } try { // Call file search service with query from message const results = await searchWorkspaceFiles( message.query || "", workspacePath, 20, // Use default limit, as filtering is now done in the backend ) // Get the RooIgnoreController from the current task, or create a new one const currentTask = provider.getCurrentTask() let rooIgnoreController = currentTask?.rooIgnoreController let tempController: RooIgnoreController | undefined // If no current task or no controller, create a temporary one if (!rooIgnoreController) { tempController = new RooIgnoreController(workspacePath) await tempController.initialize() rooIgnoreController = tempController } try { // Get showRooIgnoredFiles setting from state const { showRooIgnoredFiles = false } = (await provider.getState()) ?? {} // Filter results using RooIgnoreController if showRooIgnoredFiles is false let filteredResults = results if (!showRooIgnoredFiles && rooIgnoreController) { const allowedPaths = rooIgnoreController.filterPaths(results.map((r) => r.path)) filteredResults = results.filter((r) => allowedPaths.includes(r.path)) } // Send results back to webview await provider.postMessageToWebview({ type: "fileSearchResults", results: filteredResults, requestId: message.requestId, }) } finally { // Dispose temporary controller to prevent resource leak tempController?.dispose() } } catch (error) { const errorMessage = error instanceof Error ? error.message : String(error) // Send error response to webview await provider.postMessageToWebview({ type: "fileSearchResults", results: [], error: errorMessage, requestId: message.requestId, }) } break } case "updateTodoList": { const payload = message.payload as { todos?: any[] } const todos = payload?.todos if (Array.isArray(todos)) { await setPendingTodoList(todos) } break } case "refreshCustomTools": { try { const toolDirs = getRooDirectoriesForCwd(getCurrentCwd()).map((dir) => path.join(dir, "tools")) await customToolRegistry.loadFromDirectories(toolDirs) await provider.postMessageToWebview({ type: "customToolsResult", tools: customToolRegistry.getAllSerialized(), }) } catch (error) { await provider.postMessageToWebview({ type: "customToolsResult", tools: [], error: error instanceof Error ? error.message : String(error), }) } break } case "saveApiConfiguration": if (message.text && message.apiConfiguration) { const profileName = message.text const profileSettings = message.apiConfiguration try { // The profile rename holds the manager's cross-instance critical section across its // existence check, its save, and its compensation delete. A same-name save that // skipped that section can land between another view's check and its save and then // be removed by that rename's compensation, so this write joins the same section. // The rename callback never calls this writer, so the wrap cannot nest on itself. await provider.providerSettingsManager.runExclusiveAcrossInstances(async () => { await provider.providerSettingsManager.saveConfig(profileName, profileSettings) const listApiConfig = await provider.providerSettingsManager.listConfig() await updateGlobalState("listApiConfigMeta", listApiConfig) // The save rewrote this profile's settings in the shared store. Every other // live view pinned to it is still shadowing the pre-save settings with its // own buffer, and its running task keeps the handler built from them: the // upsert path refreshes those views through this helper, and a save to a // pinned profile owes them the same refresh. Inside the section, so a // competing rename cannot interleave with it. await provider.refreshViewLocalStateForUpdatedProfile(profileName, profileSettings) }) } catch (error) { provider.log( `Error save api configuration: ${JSON.stringify(error, Object.getOwnPropertyNames(error), 2)}`, ) vscode.window.showErrorMessage(t("common:errors.save_api_config")) } } break case "upsertApiConfiguration": if (message.text && message.apiConfiguration) { await provider.upsertProviderProfile(message.text, message.apiConfiguration) } break case "updateProfileModel": { const { expectedProvider, patch } = message.values ?? {} if ( message.text && typeof expectedProvider === "string" && patch && typeof patch === "object" && !Array.isArray(patch) ) { await provider.updateProfileModel(message.text, expectedProvider, patch) } break } case "renameApiConfiguration": if (message.values && message.apiConfiguration) { try { const { oldName, newName } = message.values if (oldName === newName) { break } // The webview's name validation treats a case-only difference from the // current profile as the current profile, so a case-only collision reaches // here as a rename onto an existing record. Reject it instead of // overwriting that profile: the rollback below would otherwise delete a // record the rename never owned. // The name check, the save, and the compensation run in one critical // section shared with every other view's manager (each view builds its own // `ProviderSettingsManager` over the same secrets): with separate locked // calls, a same-name create from another view fits between the check and // the save, and the rollback then deletes that view's record. await provider.providerSettingsManager.runExclusiveAcrossInstances(async () => { if (await provider.providerSettingsManager.hasConfig(newName)) { throw new Error(`A profile named '${newName}' already exists`) } // Load the old configuration to get its ID, and keep its full stored // record: a rollback must re-point views to the settings oldName actually // persists, not to the payload the rename attempted. const { name: _previousName, ...previousRecord } = await provider.providerSettingsManager.getProfile({ name: oldName }) const { id } = previousRecord // Create a new configuration with the new name and old ID. await provider.providerSettingsManager.saveConfig(newName, { ...message.apiConfiguration, id }) // saveConfig normalizes the record (legacy downgrades, schema parse): hand // the stored copy to the views and task handlers instead of the raw // webview payload, so unvalidated fields cannot bypass the profile-schema // normalization on the way into view state. When the read-back fails the // rename cannot proceed on a trustworthy record: remove the new record // before reporting so the failed rename cannot leave both names resolving // to the same id. let normalizedRenamed: typeof previousRecord try { const { name: _renamedName, ...renamedRecord } = await provider.providerSettingsManager.getProfile({ name: newName }) normalizedRenamed = renamedRecord } catch (error) { try { await provider.providerSettingsManager.deleteConfig(newName) } catch (cleanupError) { provider.log( `Rename rollback failed to remove '${newName}': ${JSON.stringify(cleanupError, Object.getOwnPropertyNames(cleanupError), 2)}`, ) } throw error } // Re-point live views pinned to the old name before it stops // resolving: the rename keeps the id, so their pins should follow the // record instead of dangling, and their overlays must serve the // renamed settings rather than the pre-rename copy. A failed re-point can // leave views already following newName, so undo this rename's own // durable write before reporting: the reverse re-point returns the views // that moved (the others never left oldName) and the new record goes // away, leaving the pre-rename state intact. try { await provider.repointViewLocalStateAfterProfileRename(oldName, newName, normalizedRenamed) } catch (error) { try { await provider.repointViewLocalStateAfterProfileRename(newName, oldName, previousRecord) await provider.providerSettingsManager.deleteConfig(newName) } catch (compensationError) { provider.log( `Rename compensation failed after re-point rejection: ${JSON.stringify(compensationError, Object.getOwnPropertyNames(compensationError), 2)}`, ) } throw error } // Delete the old configuration. A failure here would leave both names // resolving and every live view pinned to the new name: undo the re-point // with the previously stored record - not the attempted payload, which was // never persisted under the old name - and drop the new record so the // pre-rename state survives intact. A failed compensation is logged: both // names can then remain stored, and the log is the only trace of that // inconsistency. // The one case that does not roll back is a not-found rejection, handled below: the // old record is already gone and newName holds the only copy. try { await provider.providerSettingsManager.deleteConfig(oldName) } catch (error) { // A not-found rejection means another writer that joined the same section already // removed the old record. This call stored the settings under newName and re-pointed // the live views onto it, so newName is the only surviving copy of the profile: // rolling back would delete it and leave the views pinned to a name that resolves // to nothing. Report the failed delete and keep the renamed profile. if (error instanceof ProviderSettingsNotFoundError) { provider.log( `Rename of '${oldName}' to '${newName}': the old record was already removed; keeping '${newName}' and leaving the views on it`, ) throw error } try { await provider.repointViewLocalStateAfterProfileRename(newName, oldName, previousRecord) await provider.providerSettingsManager.deleteConfig(newName) } catch (compensationError) { provider.log( `Rename compensation failed after delete rejection: ${JSON.stringify(compensationError, Object.getOwnPropertyNames(compensationError), 2)}`, ) } throw error } }) // Re-activate to update the global settings related to the // currently activated provider profile. await provider.activateProviderProfile({ name: newName }) } catch (error) { provider.log( `Error rename api configuration: ${JSON.stringify(error, Object.getOwnPropertyNames(error), 2)}`, ) vscode.window.showErrorMessage(t("common:errors.rename_api_config")) } } break case "loadApiConfiguration": if (message.text) { try { await provider.activateProviderProfile({ name: message.text }) } catch (error) { provider.log( `Error load api configuration: ${JSON.stringify(error, Object.getOwnPropertyNames(error), 2)}`, ) vscode.window.showErrorMessage(t("common:errors.load_api_config")) } } break case "loadApiConfigurationById": if (message.text) { try { await provider.activateProviderProfile({ id: message.text }) } catch (error) { provider.log( `Error load api configuration by ID: ${JSON.stringify(error, Object.getOwnPropertyNames(error), 2)}`, ) vscode.window.showErrorMessage(t("common:errors.load_api_config")) } } break case "deleteApiConfiguration": if (message.text) { const answer = await vscode.window.showInformationMessage( t("common:confirmation.delete_config_profile"), { modal: true }, t("common:answers.yes"), ) if (answer !== t("common:answers.yes")) { break } const oldName = message.text const newName = (await provider.providerSettingsManager.listConfig()).filter( (c) => c.name !== oldName, )[0]?.name if (!newName) { vscode.window.showErrorMessage(t("common:errors.delete_api_config")) return } const entry = provider.getProviderProfileEntry(oldName) if (!entry) { vscode.window.showErrorMessage(t("common:errors.delete_api_config")) return } try { // Route the deletion through the provider: deleting the record and then // activating the survivor here left every other view pinned to the removed // profile name in its loaded state and in its durable viewStates entry. // deleteProviderProfile prunes the record, re-points the live and persisted // pins, and activates the survivor for the views that pinned the deleted one. await provider.deleteProviderProfile(entry) } catch (error) { provider.log( `Error delete api configuration: ${JSON.stringify(error, Object.getOwnPropertyNames(error), 2)}`, ) vscode.window.showErrorMessage(t("common:errors.delete_api_config")) } } break case "deleteMessageConfirm": if (!message.messageTs) { await vscode.window.showErrorMessage(t("common:errors.message.cannot_delete_missing_timestamp")) break } if (typeof message.messageTs !== "number") { await vscode.window.showErrorMessage(t("common:errors.message.cannot_delete_invalid_timestamp")) break } await handleDeleteMessageConfirm(message.messageTs, message.restoreCheckpoint) break case "editMessageConfirm": if (message.messageTs && message.text) { const resolved = await resolveIncomingImages({ text: message.text, images: message.images }) await handleEditMessageConfirm( message.messageTs, resolved.text, message.restoreCheckpoint, resolved.images, ) } break case "getListApiConfiguration": try { const listApiConfig = await provider.providerSettingsManager.listConfig() await updateGlobalState("listApiConfigMeta", listApiConfig) await provider.postMessageToWebview({ type: "listApiConfig", listApiConfig }) } catch (error) { provider.log( `Error get list api configuration: ${JSON.stringify(error, Object.getOwnPropertyNames(error), 2)}`, ) vscode.window.showErrorMessage(t("common:errors.list_api_config")) } break case "updateMcpTimeout": if (message.serverName && typeof message.timeout === "number") { try { await provider .getMcpHub() ?.updateServerTimeout( message.serverName, message.timeout, message.source as "global" | "project", ) } catch (error) { provider.log( `Failed to update timeout for ${message.serverName}: ${JSON.stringify(error, Object.getOwnPropertyNames(error), 2)}`, ) vscode.window.showErrorMessage(t("common:errors.update_server_timeout")) } } break case "updateCustomMode": if (message.modeConfig) { try { // Check if this is a new mode or an update to an existing mode const existingModes = await provider.customModesManager.getCustomModes() const isNewMode = !existingModes.some((mode) => mode.slug === message.modeConfig?.slug) await provider.customModesManager.updateCustomMode(message.modeConfig.slug, message.modeConfig) // Update state after saving the mode const customModes = await provider.customModesManager.getCustomModes() await updateGlobalState("customModes", customModes) await updateGlobalState("mode", message.modeConfig.slug) await provider.postStateToWebview() // Track telemetry for custom mode creation or update if (TelemetryService.hasInstance()) { if (isNewMode) { // This is a new custom mode TelemetryService.instance.captureCustomModeCreated( message.modeConfig.slug, message.modeConfig.name, ) } else { // Determine which setting was changed by comparing objects const existingMode = existingModes.find((mode) => mode.slug === message.modeConfig?.slug) const changedSettings = existingMode ? Object.keys(message.modeConfig).filter( (key) => JSON.stringify((existingMode as Record)[key]) !== JSON.stringify((message.modeConfig as Record)[key]), ) : [] if (changedSettings.length > 0) { TelemetryService.instance.captureModeSettingChanged(changedSettings[0]) } } } } catch { // Error already shown to user by updateCustomMode // Just prevent unhandled rejection and skip state updates } } break case "deleteCustomMode": if (message.slug) { // Get the mode details to determine source and rules folder path const customModes = await provider.customModesManager.getCustomModes() const modeToDelete = customModes.find((mode) => mode.slug === message.slug) if (!modeToDelete) { break } // Determine the scope based on source (project or global) const scope = modeToDelete.source || "global" // Determine the rules folder path let rulesFolderPath: string if (scope === "project") { const workspacePath = getWorkspacePath() if (workspacePath) { rulesFolderPath = path.join(workspacePath, ".roo", `rules-${message.slug}`) } else { rulesFolderPath = path.join(".roo", `rules-${message.slug}`) } } else { // Global scope - use OS home directory const homeDir = os.homedir() rulesFolderPath = path.join(homeDir, ".roo", `rules-${message.slug}`) } // Check if the rules folder exists const rulesFolderExists = await fileExistsAtPath(rulesFolderPath) // If this is a check request, send back the folder info if (message.checkOnly) { await provider.postMessageToWebview({ type: "deleteCustomModeCheck", slug: message.slug, rulesFolderPath: rulesFolderExists ? rulesFolderPath : undefined, }) break } // Delete the mode await provider.customModesManager.deleteCustomMode(message.slug) // Delete the rules folder if it exists if (rulesFolderExists) { try { await fs.rm(rulesFolderPath, { recursive: true, force: true }) provider.log(`Deleted rules folder for mode ${message.slug}: ${rulesFolderPath}`) } catch (error) { provider.log(`Failed to delete rules folder for mode ${message.slug}: ${error}`) // Notify the user about the failure vscode.window.showErrorMessage( t("common:errors.delete_rules_folder_failed", { rulesFolderPath, error: error instanceof Error ? error.message : String(error), }), ) // Continue with mode deletion even if folder deletion fails } } // Switch back to default mode after deletion await updateGlobalState("mode", defaultModeSlug) await provider.postStateToWebview() } break case "exportMode": if (message.slug) { try { // Get custom mode prompts to check if built-in mode has been customized const customModePrompts = getGlobalState("customModePrompts") || {} const customPrompt = customModePrompts[message.slug] // Export the mode with any customizations merged directly const result = await provider.customModesManager.exportModeWithRules(message.slug, customPrompt) if (result.success && result.yaml) { const defaultUri = await resolveDefaultSaveUri( provider.contextProxy, "lastModeExportPath", `${message.slug}-export.yaml`, { useWorkspace: true, fallbackDir: path.join(os.homedir(), "Downloads"), }, ) // Show save dialog const saveUri = await vscode.window.showSaveDialog({ defaultUri, filters: { "YAML files": ["yaml", "yml"], }, title: "Save mode export", }) if (saveUri && result.yaml) { // Save the directory for next time await saveLastExportPath(provider.contextProxy, "lastModeExportPath", saveUri) // Write the file to the selected location await fs.writeFile(saveUri.fsPath, result.yaml, "utf-8") // Send success message to webview await provider.postMessageToWebview({ type: "exportModeResult", success: true, slug: message.slug, }) // Show info message vscode.window.showInformationMessage(t("common:info.mode_exported", { mode: message.slug })) } else { // User cancelled the save dialog await provider.postMessageToWebview({ type: "exportModeResult", success: false, error: "Export cancelled", slug: message.slug, }) } } else { // Send error message to webview await provider.postMessageToWebview({ type: "exportModeResult", success: false, error: result.error, slug: message.slug, }) } } catch (error) { const errorMessage = error instanceof Error ? error.message : String(error) provider.log(`Failed to export mode ${message.slug}: ${errorMessage}`) // Send error message to webview await provider.postMessageToWebview({ type: "exportModeResult", success: false, error: errorMessage, slug: message.slug, }) } } break case "importMode": try { // Get last used directory for import const lastImportPath = getGlobalState("lastModeImportPath") let defaultUri: vscode.Uri | undefined if (lastImportPath) { // Use the directory from the last import const lastDir = path.dirname(lastImportPath) defaultUri = vscode.Uri.file(lastDir) } else { // Default to workspace or home directory const workspaceFolders = vscode.workspace.workspaceFolders if (workspaceFolders && workspaceFolders.length > 0) { defaultUri = vscode.Uri.file(workspaceFolders[0].uri.fsPath) } } // Show file picker to select YAML file const fileUri = await vscode.window.showOpenDialog({ canSelectFiles: true, canSelectFolders: false, canSelectMany: false, defaultUri, filters: { "YAML files": ["yaml", "yml"], }, title: "Select mode export file to import", }) if (fileUri && fileUri[0]) { // Save the directory for next time await updateGlobalState("lastModeImportPath", fileUri[0].fsPath) // Read the file content const yamlContent = await fs.readFile(fileUri[0].fsPath, "utf-8") // Import the mode with the specified source level const result = await provider.customModesManager.importModeWithRules( yamlContent, message.source || "project", // Default to project if not specified ) if (result.success) { // Update state after importing const customModes = await provider.customModesManager.getCustomModes() await updateGlobalState("customModes", customModes) await provider.postStateToWebview() // Send success message to webview, include the imported slug so UI can switch await provider.postMessageToWebview({ type: "importModeResult", success: true, slug: result.slug, }) // Show success message vscode.window.showInformationMessage(t("common:info.mode_imported")) } else { // Send error message to webview await provider.postMessageToWebview({ type: "importModeResult", success: false, error: result.error, }) // Show error message vscode.window.showErrorMessage(t("common:errors.mode_import_failed", { error: result.error })) } } else { // User cancelled the file dialog - reset the importing state await provider.postMessageToWebview({ type: "importModeResult", success: false, error: "cancelled", }) } } catch (error) { const errorMessage = error instanceof Error ? error.message : String(error) provider.log(`Failed to import mode: ${errorMessage}`) // Send error message to webview await provider.postMessageToWebview({ type: "importModeResult", success: false, error: errorMessage, }) // Show error message vscode.window.showErrorMessage(t("common:errors.mode_import_failed", { error: errorMessage })) } break case "checkRulesDirectory": if (message.slug) { const hasContent = await provider.customModesManager.checkRulesDirectoryHasContent(message.slug) await provider.postMessageToWebview({ type: "checkRulesDirectoryResult", slug: message.slug, hasContent: hasContent, }) } break case "telemetrySetting": { // Chain onto the shared queue so a concurrent "telemetrySetting" message (e.g. a // rapid toggle) can't interleave its read-write-apply sequence with this one -- see // the telemetrySettingQueue comment above for why that matters. Swallow a prior // link's rejection before chaining (rather than letting .then() propagate it) so one // failed update can't permanently poison every subsequent telemetrySetting message // for the rest of the session. const thisUpdate = telemetrySettingQueue .catch(() => undefined) .then(async () => { const telemetrySetting = message.text as TelemetrySetting const previousSetting = getGlobalState("telemetrySetting") || "unset" const isOptedIn = isTelemetryOptedIn(telemetrySetting) const wasPreviouslyOptedIn = isTelemetryOptedIn(previousSetting) // If turning telemetry OFF, fire event BEFORE disabling if (wasPreviouslyOptedIn && !isOptedIn && TelemetryService.hasInstance()) { TelemetryService.instance.captureTelemetrySettingsChanged(previousSetting, telemetrySetting) } // Update the telemetry state. vscode.env.isTelemetryEnabled is ANDed in // (matching extension.ts's onDidChangeTelemetryEnabled listener) so this can't // re-enable telemetry while VS Code's global toggle is off -- the // captureTelemetrySettingsChanged calls above/below still track the user's // stored preference transition on its own, independent of that live toggle. await updateGlobalState("telemetrySetting", telemetrySetting) if (TelemetryService.hasInstance()) { TelemetryService.instance.updateTelemetryState(isOptedIn && vscode.env.isTelemetryEnabled) } // If turning telemetry ON, fire event AFTER enabling if (!wasPreviouslyOptedIn && isOptedIn && TelemetryService.hasInstance()) { TelemetryService.instance.captureTelemetrySettingsChanged(previousSetting, telemetrySetting) } await provider.postStateToWebview() }) telemetrySettingQueue = thisUpdate await thisUpdate break } case "debugSetting": { await vscode.workspace .getConfiguration(Package.name) .update("debug", message.bool ?? false, vscode.ConfigurationTarget.Global) await provider.postStateToWebview() break } case "rooCloudSignIn": { if (!isCloudServiceAvailable()) { provider.log("CloudService unavailable; ignoring rooCloudSignIn") showCloudUnavailableMessage() break } try { TelemetryService.instance.captureEvent(TelemetryEventName.AUTHENTICATION_INITIATED) // Use provider signup flow if useProviderSignup is explicitly true await CloudService.instance.login(undefined, message.useProviderSignup ?? false) } catch (error) { provider.log(`AuthService#login failed: ${error}`) vscode.window.showErrorMessage("Sign in failed.") } break } case "cloudLandingPageSignIn": { if (!isCloudServiceAvailable()) { provider.log("CloudService unavailable; ignoring cloudLandingPageSignIn") showCloudUnavailableMessage() break } try { const landingPageSlug = message.text || "supernova" TelemetryService.instance.captureEvent(TelemetryEventName.AUTHENTICATION_INITIATED) await CloudService.instance.login(landingPageSlug) } catch (error) { provider.log(`CloudService#login failed: ${error}`) vscode.window.showErrorMessage("Sign in failed.") } break } case "rooCloudSignOut": { if (!isCloudServiceAvailable()) { await provider.postStateToWebview() await provider.postMessageToWebview({ type: "authenticatedUser", userInfo: undefined }) break } try { await CloudService.instance.logout() await provider.postStateToWebview() await provider.postMessageToWebview({ type: "authenticatedUser", userInfo: undefined }) } catch (error) { provider.log(`AuthService#logout failed: ${error}`) vscode.window.showErrorMessage("Sign out failed.") } break } case "openAiCodexSignIn": { try { const { openAiCodexOAuthManager } = await import("../../integrations/openai-codex/oauth") const authUrl = openAiCodexOAuthManager.startAuthorizationFlow() // Open the authorization URL in the browser await vscode.env.openExternal(vscode.Uri.parse(authUrl)) // Wait for the callback in a separate promise (non-blocking) openAiCodexOAuthManager .waitForCallback() .then(async () => { vscode.window.showInformationMessage("Successfully signed in to OpenAI Codex") await provider.postStateToWebview() }) .catch((error) => { provider.log(`OpenAI Codex OAuth callback failed: ${error}`) if (!String(error).includes("timed out")) { vscode.window.showErrorMessage(`OpenAI Codex sign in failed: ${error.message || error}`) } }) } catch (error) { provider.log(`OpenAI Codex OAuth failed: ${error}`) vscode.window.showErrorMessage("OpenAI Codex sign in failed.") } break } case "openAiCodexSignOut": { try { const { openAiCodexOAuthManager } = await import("../../integrations/openai-codex/oauth") await openAiCodexOAuthManager.clearCredentials() vscode.window.showInformationMessage("Signed out from OpenAI Codex") await provider.postStateToWebview() } catch (error) { provider.log(`OpenAI Codex sign out failed: ${error}`) vscode.window.showErrorMessage("OpenAI Codex sign out failed.") } break } case "kimiCodeSignIn": { try { const { kimiCodeOAuthManager } = await import("../../integrations/kimi-code/oauth") const device = await kimiCodeOAuthManager.startAuthorization() await provider.postStateToWebview() await vscode.env.openExternal( vscode.Uri.parse(device.verificationUriComplete ?? device.verificationUri), ) void kimiCodeOAuthManager .waitForAuthorization() .then(async () => { vscode.window.showInformationMessage("Successfully signed in to Kimi Code") await provider.postStateToWebview() }) .catch(async (error) => { provider.log(`Kimi Code OAuth failed: ${error}`) await provider.postStateToWebview() }) } catch (error) { provider.log(`Kimi Code OAuth failed: ${error}`) vscode.window.showErrorMessage( `Kimi Code sign in failed: ${error instanceof Error ? error.message : error}`, ) await provider.postStateToWebview() } break } case "kimiCodeSignOut": { try { const { kimiCodeOAuthManager } = await import("../../integrations/kimi-code/oauth") await kimiCodeOAuthManager.clearCredentials() vscode.window.showInformationMessage("Signed out from Kimi Code") await provider.postStateToWebview() } catch (error) { provider.log(`Kimi Code sign out failed: ${error}`) vscode.window.showErrorMessage("Kimi Code sign out failed.") } break } case "rooCloudManualUrl": { if (!isCloudServiceAvailable()) { provider.log("CloudService unavailable; ignoring rooCloudManualUrl") showCloudUnavailableMessage() break } try { if (!message.text) { vscode.window.showErrorMessage(t("common:errors.manual_url_empty")) break } // Parse the callback URL to extract parameters const callbackUrl = message.text.trim() const uri = vscode.Uri.parse(callbackUrl) if (!uri.query) { throw new Error(t("common:errors.manual_url_no_query")) } const query = new URLSearchParams(uri.query) const code = query.get("code") const state = query.get("state") const organizationId = query.get("organizationId") if (!code || !state) { throw new Error(t("common:errors.manual_url_missing_params")) } // Reuse the existing authentication flow await CloudService.instance.handleAuthCallback( code, state, organizationId === "null" ? null : organizationId, ) await provider.postStateToWebview() } catch (error) { provider.log(`ManualUrl#handleAuthCallback failed: ${error}`) const errorMessage = error instanceof Error ? error.message : t("common:errors.manual_url_auth_failed") // Show error message through VS Code UI vscode.window.showErrorMessage(`${t("common:errors.manual_url_auth_error")}: ${errorMessage}`) } break } case "clearCloudAuthSkipModel": { // Clear the flag that indicates auth completed without model selection await provider.context.globalState.update("roo-auth-skip-model", undefined) await provider.postStateToWebview() break } case "zooCodeSignOut": { try { const { disconnectZooCode } = await import("../../services/zoo-code-auth") await disconnectZooCode() // Clear zooSessionToken from ALL provider profiles with apiProvider === "zoo-gateway". // Profiles are user-renameable, so we cannot rely on a hardcoded name like "Zoo Gateway". // We must scan all profiles and clear tokens from any that use the zoo-gateway provider. try { const allProfiles = await provider.providerSettingsManager.listConfig() // Check if Zoo Gateway is the currently active profile by apiProvider identity const currentSettings = provider.contextProxy.getProviderSettings() const isZooGatewayActive = currentSettings.apiProvider === providerIdentifiers.zooGateway const currentApiConfigName = provider.contextProxy.getValues().currentApiConfigName for (const entry of allProfiles) { if (entry.apiProvider !== providerIdentifiers.zooGateway) { continue } // Isolate per-profile failures: a corrupted profile or a failed write // for one entry must not abort cleanup of the remaining profiles, // otherwise sign-out would leave later profiles with a stale token. try { const profile = await provider.providerSettingsManager.getProfile({ name: entry.name }) const { zooSessionToken: _removed, ...cleanedProfile } = profile // If this is the currently active profile, ALWAYS push to the in-memory // handler — even when the persisted profile has already been cleared — // because currentSettings (and therefore the live API handler) may still // carry a stale token from before sign-out. Persisted-only profiles get // rewritten only when they previously had a token to avoid no-op disk writes. const isThisProfileActive = isZooGatewayActive && currentApiConfigName === entry.name if (isThisProfileActive) { await provider.upsertProviderProfile(entry.name, cleanedProfile, true) provider.log( `[zooCodeSignOut] Cleared zooSessionToken from "${entry.name}" profile and updated in-memory handler`, ) } else if (profile.zooSessionToken) { await provider.providerSettingsManager.saveConfig(entry.name, cleanedProfile) provider.log(`[zooCodeSignOut] Cleared zooSessionToken from "${entry.name}" profile`) } } catch (profileError) { // Log but continue to the next profile so one failure doesn't // leave other profiles holding a stale token. provider.log( `[zooCodeSignOut] Failed to clear profile token for "${entry.name}": ${profileError instanceof Error ? profileError.message : String(profileError)}`, ) } } } catch (profileError) { // listConfig itself failed — nothing to iterate. provider.log( `[zooCodeSignOut] Failed to list profiles for token cleanup: ${profileError instanceof Error ? profileError.message : String(profileError)}`, ) } await provider.postStateToWebview() } catch (error) { provider.log( `Failed to sign out of Zoo Code: ${error instanceof Error ? error.message : String(error)}`, ) } break } case "switchOrganization": { try { const organizationId = message.organizationId ?? null // Switch to the new organization context await CloudService.instance.switchOrganization(organizationId) // Refresh the state to update UI await provider.postStateToWebview() // Send success response back to webview await provider.postMessageToWebview({ type: "organizationSwitchResult", success: true, organizationId: organizationId, }) } catch (error) { provider.log(`Organization switch failed: ${error}`) const errorMessage = error instanceof Error ? error.message : String(error) // Send error response back to webview await provider.postMessageToWebview({ type: "organizationSwitchResult", success: false, error: errorMessage, organizationId: message.organizationId ?? null, }) vscode.window.showErrorMessage(`Failed to switch organization: ${errorMessage}`) } break } case "saveCodeIndexSettingsAtomic": { if (!message.codeIndexSettings) { break } const settings = message.codeIndexSettings try { // Check if embedder provider has changed const currentConfig = getGlobalState("codebaseIndexConfig") || {} const embedderProviderChanged = currentConfig.codebaseIndexEmbedderProvider !== settings.codebaseIndexEmbedderProvider // Save global state settings atomically const globalStateConfig = { ...currentConfig, codebaseIndexEnabled: settings.codebaseIndexEnabled, codebaseIndexQdrantUrl: settings.codebaseIndexQdrantUrl, codebaseIndexEmbedderProvider: settings.codebaseIndexEmbedderProvider, codebaseIndexEmbedderBaseUrl: settings.codebaseIndexEmbedderBaseUrl, codebaseIndexEmbedderModelId: settings.codebaseIndexEmbedderModelId, codebaseIndexEmbedderModelDimension: settings.codebaseIndexEmbedderModelDimension, // Generic dimension codebaseIndexOpenAiCompatibleBaseUrl: settings.codebaseIndexOpenAiCompatibleBaseUrl, codebaseIndexBedrockRegion: settings.codebaseIndexBedrockRegion, codebaseIndexBedrockProfile: settings.codebaseIndexBedrockProfile, codebaseIndexSearchMaxResults: settings.codebaseIndexSearchMaxResults, codebaseIndexSearchMinScore: settings.codebaseIndexSearchMinScore, codebaseIndexOpenRouterSpecificProvider: settings.codebaseIndexOpenRouterSpecificProvider, } // Save global state first await updateGlobalState("codebaseIndexConfig", globalStateConfig) // Save secrets directly using context proxy if (settings.codeIndexOpenAiKey !== undefined) { await provider.contextProxy.storeSecret("codeIndexOpenAiKey", settings.codeIndexOpenAiKey) } if (settings.codeIndexQdrantApiKey !== undefined) { await provider.contextProxy.storeSecret("codeIndexQdrantApiKey", settings.codeIndexQdrantApiKey) } if (settings.codebaseIndexOpenAiCompatibleApiKey !== undefined) { await provider.contextProxy.storeSecret( "codebaseIndexOpenAiCompatibleApiKey", settings.codebaseIndexOpenAiCompatibleApiKey, ) } if (settings.codebaseIndexGeminiApiKey !== undefined) { await provider.contextProxy.storeSecret( "codebaseIndexGeminiApiKey", settings.codebaseIndexGeminiApiKey, ) } if (settings.codebaseIndexMistralApiKey !== undefined) { await provider.contextProxy.storeSecret( "codebaseIndexMistralApiKey", settings.codebaseIndexMistralApiKey, ) } if (settings.codebaseIndexVercelAiGatewayApiKey !== undefined) { await provider.contextProxy.storeSecret( "codebaseIndexVercelAiGatewayApiKey", settings.codebaseIndexVercelAiGatewayApiKey, ) } if (settings.codebaseIndexOpenRouterApiKey !== undefined) { await provider.contextProxy.storeSecret( "codebaseIndexOpenRouterApiKey", settings.codebaseIndexOpenRouterApiKey, ) } // Send success response first - settings are saved regardless of validation await provider.postMessageToWebview({ type: "codeIndexSettingsSaved", success: true, settings: globalStateConfig, }) // Update webview state await provider.postStateToWebview() // Then handle validation and initialization for the current workspace const scope = provider.getCurrentWorkspaceCodeIndexScope() const currentCodeIndexManager = scope?.codeIndexManager if (currentCodeIndexManager) { // If embedder provider changed, perform proactive validation if (embedderProviderChanged) { try { // Force handleSettingsChange which will trigger validation await currentCodeIndexManager.handleSettingsChange() } catch (error) { // Validation failed - the error state is already set by handleSettingsChange provider.log( `Embedder validation failed after provider change: ${error instanceof Error ? error.message : String(error)}`, ) // Send validation error to webview await provider.postMessageToWebview({ type: "indexingStatusUpdate", values: currentCodeIndexManager.getCurrentStatus(), }) // Exit early - don't try to start indexing with invalid configuration break } } else { // No provider change, just handle settings normally try { await currentCodeIndexManager.handleSettingsChange() } catch (error) { // Log but don't fail - settings are saved provider.log( `Settings change handling error: ${error instanceof Error ? error.message : String(error)}`, ) } } // Wait a bit more to ensure everything is ready await new Promise((resolve) => setTimeout(resolve, 200)) // Auto-start indexing if now enabled and configured if (currentCodeIndexManager.isFeatureEnabled && currentCodeIndexManager.isFeatureConfigured) { if (!currentCodeIndexManager.isInitialized) { try { await currentCodeIndexManager.initialize(provider.contextProxy) provider.log(`Code index manager initialized after settings save`) } catch (error) { provider.log( `Code index initialization failed: ${error instanceof Error ? error.message : String(error)}`, ) // Send error status to webview await provider.postMessageToWebview({ type: "indexingStatusUpdate", values: currentCodeIndexManager.getCurrentStatus(), }) } } } } else { // No workspace open - send error status provider.log("Cannot save code index settings: No workspace folder open") await provider.postMessageToWebview({ type: "indexingStatusUpdate", values: { systemStatus: "Error", message: t("embeddings:orchestrator.indexingRequiresWorkspace"), processedItems: 0, totalItems: 0, currentItemUnit: "items", }, }) } } catch (error) { provider.log(`Error saving code index settings: ${error.message || error}`) await provider.postMessageToWebview({ type: "codeIndexSettingsSaved", success: false, error: error.message || "Failed to save settings", }) } break } case "requestIndexingStatus": { const scope = provider.getCurrentWorkspaceCodeIndexScope() const manager = scope?.codeIndexManager if (!manager) { // No workspace open - send error status await provider.postMessageToWebview({ type: "indexingStatusUpdate", values: { systemStatus: "Error", message: t("embeddings:orchestrator.indexingRequiresWorkspace"), processedItems: 0, totalItems: 0, currentItemUnit: "items", workerspacePath: undefined, }, }) return } const status = manager ? manager.getCurrentStatus() : { systemStatus: "Standby", message: "No workspace folder open", processedItems: 0, totalItems: 0, currentItemUnit: "items", workspacePath: undefined, } await provider.postMessageToWebview({ type: "indexingStatusUpdate", values: status, }) break } case "requestCodeIndexSecretStatus": { // Check if secrets are set using the VSCode context directly for async access const hasOpenAiKey = !!(await provider.context.secrets.get("codeIndexOpenAiKey")) const hasQdrantApiKey = !!(await provider.context.secrets.get("codeIndexQdrantApiKey")) const hasOpenAiCompatibleApiKey = !!(await provider.context.secrets.get( "codebaseIndexOpenAiCompatibleApiKey", )) const hasGeminiApiKey = !!(await provider.context.secrets.get("codebaseIndexGeminiApiKey")) const hasMistralApiKey = !!(await provider.context.secrets.get("codebaseIndexMistralApiKey")) const hasVercelAiGatewayApiKey = !!(await provider.context.secrets.get( "codebaseIndexVercelAiGatewayApiKey", )) const hasOpenRouterApiKey = !!(await provider.context.secrets.get("codebaseIndexOpenRouterApiKey")) await provider.postMessageToWebview({ type: "codeIndexSecretStatus", values: { hasOpenAiKey, hasQdrantApiKey, hasOpenAiCompatibleApiKey, hasGeminiApiKey, hasMistralApiKey, hasVercelAiGatewayApiKey, hasOpenRouterApiKey, }, }) break } case "startIndexing": { try { const scope = provider.getCurrentWorkspaceCodeIndexScope() const manager = scope?.codeIndexManager if (!manager) { await provider.postMessageToWebview({ type: "indexingStatusUpdate", values: { systemStatus: "Error", message: t("embeddings:orchestrator.indexingRequiresWorkspace"), processedItems: 0, totalItems: 0, currentItemUnit: "items", }, }) provider.log("Cannot start indexing: No workspace folder open") return } // "Start Indexing" implicitly enables the workspace await manager.setWorkspaceEnabled(true) if (manager.isFeatureEnabled && manager.isFeatureConfigured) { await manager.initialize(provider.contextProxy) const currentState = manager.state if (currentState === "Standby" || currentState === "Error") { void manager.startIndexing().catch((err) => provider.log(`Indexing error: ${err}`)) if (!manager.isInitialized) { await manager.initialize(provider.contextProxy) if (manager.state === "Standby" || manager.state === "Error") { void manager.startIndexing().catch((err) => provider.log(`Indexing error: ${err}`)) } } } } } catch (error) { provider.log(`Error starting indexing: ${error instanceof Error ? error.message : String(error)}`) } break } case "stopIndexing": { try { const scope = provider.getCurrentWorkspaceCodeIndexScope() if (!scope) { provider.log("Cannot stop indexing: No workspace folder open") return } scope.codeIndexManager.stopIndexing() await provider.postMessageToWebview({ type: "indexingStatusUpdate", values: scope.codeIndexManager.getCurrentStatus(), }) } catch (error) { provider.log(`Error stopping indexing: ${error instanceof Error ? error.message : String(error)}`) } break } case "toggleWorkspaceIndexing": { try { const scope = provider.getCurrentWorkspaceCodeIndexScope() if (!scope) { provider.log("Cannot toggle workspace indexing: No workspace folder open") return } await scope.workspaceIndexingEnablementManager.setEnabled(message.bool ?? false, provider) } catch (error) { provider.log( `Error toggling workspace indexing: ${error instanceof Error ? error.message : String(error)}`, ) } break } case "setAutoEnableDefault": { try { const scope = provider.getCurrentWorkspaceCodeIndexScope() const manager = scope?.codeIndexManager if (!manager) { provider.log("Cannot set auto-enable default: No workspace folder open") return } // Capture prior state for every manager before persisting the global change const allManagers = CodeIndexManagerRegistry.getAllInstances() const priorStates = new Map(allManagers.map((m) => [m, m.isWorkspaceEnabled])) await manager.setAutoEnableDefault(message.bool ?? true) // Apply stop/start to every affected manager for (const m of allManagers) { const wasEnabled = priorStates.get(m)! const isNowEnabled = m.isWorkspaceEnabled if (wasEnabled && !isNowEnabled) { m.stopIndexing() } else if (!wasEnabled && isNowEnabled && m.isFeatureEnabled && m.isFeatureConfigured) { await m.initialize(provider.contextProxy) void m.startIndexing().catch((err) => provider.log(`Indexing error: ${err}`)) } } await provider.postMessageToWebview({ type: "indexingStatusUpdate", values: manager.getCurrentStatus(), }) } catch (error) { provider.log( `Error setting auto-enable default: ${error instanceof Error ? error.message : String(error)}`, ) } break } case "clearIndexData": { try { const scope = provider.getCurrentWorkspaceCodeIndexScope() if (!scope) { provider.log("Cannot clear index data: No workspace folder open") await provider.postMessageToWebview({ type: "indexCleared", values: { success: false, error: t("embeddings:orchestrator.indexingRequiresWorkspace"), }, }) return } await scope.codeIndexManager.clearIndexData() await provider.postMessageToWebview({ type: "indexCleared", values: { success: true } }) } catch (error) { provider.log(`Error clearing index data: ${error instanceof Error ? error.message : String(error)}`) await provider.postMessageToWebview({ type: "indexCleared", values: { success: false, error: error instanceof Error ? error.message : String(error), }, }) } break } case "focusPanelRequest": { // Execute the focusPanel command to focus the WebView await vscode.commands.executeCommand(getCommand("focusPanel")) break } case "filterMarketplaceItems": { if (marketplaceManager && message.filters) { try { await marketplaceManager.updateWithFilteredItems({ type: message.filters.type as MarketplaceItemType | undefined, search: message.filters.search, tags: message.filters.tags, }) await provider.postStateToWebview() } catch (error) { console.error("Marketplace: Error filtering items:", error) vscode.window.showErrorMessage("Failed to filter marketplace items") } } break } case "fetchMarketplaceData": { // Fetch marketplace data on demand await provider.fetchMarketplaceData() break } case "installMarketplaceItem": { if (marketplaceManager && message.mpItem && message.mpInstallOptions) { try { const configFilePath = await marketplaceManager.installMarketplaceItem( message.mpItem, message.mpInstallOptions, ) await provider.postStateToWebview() console.log(`Marketplace item installed and config file opened: ${configFilePath}`) // Send success message to webview await provider.postMessageToWebview({ type: "marketplaceInstallResult", success: true, slug: message.mpItem.id, }) } catch (error) { console.error(`Error installing marketplace item: ${error}`) // Send error message to webview await provider.postMessageToWebview({ type: "marketplaceInstallResult", success: false, error: error instanceof Error ? error.message : String(error), slug: message.mpItem.id, }) } } break } case "removeInstalledMarketplaceItem": { if (marketplaceManager && message.mpItem && message.mpInstallOptions) { try { await marketplaceManager.removeInstalledMarketplaceItem(message.mpItem, message.mpInstallOptions) await provider.postStateToWebview() // Send success message to webview await provider.postMessageToWebview({ type: "marketplaceRemoveResult", success: true, slug: message.mpItem.id, }) } catch (error) { console.error(`Error removing marketplace item: ${error}`) // Show error message to user vscode.window.showErrorMessage( `Failed to remove marketplace item: ${error instanceof Error ? error.message : String(error)}`, ) // Send error message to webview await provider.postMessageToWebview({ type: "marketplaceRemoveResult", success: false, error: error instanceof Error ? error.message : String(error), slug: message.mpItem.id, }) } } else { // MarketplaceManager not available or missing required parameters const errorMessage = !marketplaceManager ? "Marketplace manager is not available" : "Missing required parameters for marketplace item removal" console.error(errorMessage) vscode.window.showErrorMessage(errorMessage) if (message.mpItem?.id) { await provider.postMessageToWebview({ type: "marketplaceRemoveResult", success: false, error: errorMessage, slug: message.mpItem.id, }) } } break } case "installMarketplaceItemWithParameters": { if (marketplaceManager && message.payload && "item" in message.payload && "parameters" in message.payload) { try { const configFilePath = await marketplaceManager.installMarketplaceItem(message.payload.item, { parameters: message.payload.parameters, }) await provider.postStateToWebview() console.log(`Marketplace item with parameters installed and config file opened: ${configFilePath}`) } catch (error) { console.error(`Error installing marketplace item with parameters: ${error}`) vscode.window.showErrorMessage( `Failed to install marketplace item: ${error instanceof Error ? error.message : String(error)}`, ) } } break } case "switchTab": { if (message.tab) { // Capture tab shown event for all switchTab messages (which are user-initiated). if (TelemetryService.hasInstance()) { TelemetryService.instance.captureTabShown(message.tab) } await provider.postMessageToWebview({ type: "action", action: "switchTab", tab: message.tab, values: message.values, }) } break } case "requestCommands": { try { const commandList = await getDiscoveredCommands() await provider.postMessageToWebview({ type: "commands", commands: commandList }) } catch (error) { provider.log(`Error fetching commands: ${JSON.stringify(error, Object.getOwnPropertyNames(error), 2)}`) await provider.postMessageToWebview({ type: "commands", commands: [] }) } break } case "requestModes": { try { const modes = await provider.getModes() await provider.postMessageToWebview({ type: "modes", modes }) } catch (error) { provider.log(`Error fetching modes: ${JSON.stringify(error, Object.getOwnPropertyNames(error), 2)}`) await provider.postMessageToWebview({ type: "modes", modes: [] }) } break } case "requestSkills": { await handleRequestSkills(provider) break } case "createSkill": { await handleCreateSkill(provider, message) break } case "deleteSkill": { await handleDeleteSkill(provider, message) break } case "moveSkill": { await handleMoveSkill(provider, message) break } case "updateSkillModes": { await handleUpdateSkillModes(provider, message) break } case "openSkillFile": { await handleOpenSkillFile(provider, message) break } case "requestRules": { await handleRequestRules(provider, getCurrentCwd()) break } case "createRule": { await handleCreateRule(provider, getCurrentCwd(), message) break } case "deleteRule": { await handleDeleteRule(provider, getCurrentCwd(), message) break } case "openRuleFile": { await handleOpenRuleFile(provider, getCurrentCwd(), message) break } case "openRulesDirectory": { await handleOpenRulesDirectory(provider, getCurrentCwd(), message) break } case "openCommandFile": { try { if (message.text) { const { getCommand } = await import("../../services/command/commands") const command = await getCommand(getCurrentCwd(), message.text) if (command && command.filePath) { await openFile(command.filePath) } else { vscode.window.showErrorMessage(t("common:errors.command_not_found", { name: message.text })) } } } catch (error) { provider.log( `Error opening command file: ${JSON.stringify(error, Object.getOwnPropertyNames(error), 2)}`, ) vscode.window.showErrorMessage(t("common:errors.open_command_file")) } break } case "deleteCommand": { try { if (message.text && message.values?.source) { const { getCommand } = await import("../../services/command/commands") const command = await getCommand(getCurrentCwd(), message.text) if (command && command.filePath) { // Delete the command file await fs.unlink(command.filePath) provider.log(`Deleted command file: ${command.filePath}`) } else { vscode.window.showErrorMessage(t("common:errors.command_not_found", { name: message.text })) } } } catch (error) { provider.log(`Error deleting command: ${JSON.stringify(error, Object.getOwnPropertyNames(error), 2)}`) vscode.window.showErrorMessage(t("common:errors.delete_command")) } break } case "createCommand": { try { const source = message.values?.source as "global" | "project" const fileName = message.text // Custom filename from user input if (!source) { provider.log("Missing source for createCommand") break } // Determine the commands directory based on source let commandsDir: string if (source === "global") { const globalConfigDir = path.join(os.homedir(), ".roo") commandsDir = path.join(globalConfigDir, "commands") } else { if (!vscode.workspace.workspaceFolders?.length) { vscode.window.showErrorMessage(t("common:errors.no_workspace")) return } // Project commands const workspaceRoot = getCurrentCwd() if (!workspaceRoot) { vscode.window.showErrorMessage(t("common:errors.no_workspace_for_project_command")) break } commandsDir = path.join(workspaceRoot, ".roo", "commands") } // Ensure the commands directory exists await fs.mkdir(commandsDir, { recursive: true }) // Use provided filename or generate a unique one let commandName: string if (fileName && fileName.trim()) { let cleanFileName = fileName.trim() // Strip leading slash if present if (cleanFileName.startsWith("/")) { cleanFileName = cleanFileName.substring(1) } // Remove .md extension if present BEFORE slugification if (cleanFileName.toLowerCase().endsWith(".md")) { cleanFileName = cleanFileName.slice(0, -3) } // Slugify the command name: lowercase, replace spaces with dashes, remove special characters commandName = cleanFileName .toLowerCase() .replace(/\s+/g, "-") // Replace spaces with dashes .replace(/[^a-z0-9-]/g, "") // Remove special characters except dashes .replace(/-+/g, "-") // Replace multiple dashes with single dash .replace(/^-|-$/g, "") // Remove leading/trailing dashes // Ensure we have a valid command name if (!commandName || commandName.length === 0) { commandName = "new-command" } } else { // Generate a unique command name commandName = "new-command" let counter = 1 let filePath = path.join(commandsDir, `${commandName}.md`) while ( await fs .access(filePath) .then(() => true) .catch(() => false) ) { commandName = `new-command-${counter}` filePath = path.join(commandsDir, `${commandName}.md`) counter++ } } const filePath = path.join(commandsDir, `${commandName}.md`) // Check if file already exists if ( await fs .access(filePath) .then(() => true) .catch(() => false) ) { vscode.window.showErrorMessage(t("common:errors.command_already_exists", { commandName })) break } // Create the command file with template content const templateContent = t("common:errors.command_template_content") await fs.writeFile(filePath, templateContent, "utf8") provider.log(`Created new command file: ${filePath}`) // Open the new file in the editor await openFile(filePath) // Refresh commands list const { getCommands } = await import("../../services/command/commands") const commands = await getCommands(getCurrentCwd() || "") const commandList = commands.map((command) => ({ name: command.name, source: command.source, filePath: command.filePath, description: command.description, argumentHint: command.argumentHint, })) await provider.postMessageToWebview({ type: "commands", commands: commandList, }) } catch (error) { provider.log(`Error creating command: ${JSON.stringify(error, Object.getOwnPropertyNames(error), 2)}`) vscode.window.showErrorMessage(t("common:errors.create_command_failed")) } break } case "insertTextIntoTextarea": { const text = message.text if (text) { // Send message to insert text into the chat textarea await provider.postMessageToWebview({ type: "insertTextIntoTextarea", text: text, }) } break } case "showMdmAuthRequiredNotification": { // Show notification that organization requires authentication vscode.window.showWarningMessage(t("common:mdm.info.organization_requires_auth")) break } /** * Chat Message Queue */ case "queueMessage": { const resolved = await resolveIncomingImages({ text: message.text, images: message.images }) provider.getCurrentTask()?.messageQueueService.addMessage(resolved.text, resolved.images) break } case "removeQueuedMessage": { provider.getCurrentTask()?.messageQueueService.removeMessage(message.text ?? "") break } case "editQueuedMessage": { if (message.payload) { const { id, text, images } = message.payload as EditQueuedMessagePayload provider.getCurrentTask()?.messageQueueService.updateMessage(id, text, images) } break } case "dismissUpsell": { if (message.upsellId) { try { // Get current list of dismissed upsells const dismissedUpsells = getGlobalState("dismissedUpsells") || [] // Add the new upsell ID if not already present let updatedList = dismissedUpsells if (!dismissedUpsells.includes(message.upsellId)) { updatedList = [...dismissedUpsells, message.upsellId] await updateGlobalState("dismissedUpsells", updatedList) } // Send updated list back to webview (use the already computed updatedList) await provider.postMessageToWebview({ type: "dismissedUpsells", list: updatedList, }) } catch (error) { // Fail silently as per Bruno's comment - it's OK to fail silently in this case provider.log(`Failed to dismiss upsell: ${error instanceof Error ? error.message : String(error)}`) } } break } case "getDismissedUpsells": { // Send the current list of dismissed upsells to the webview const dismissedUpsells = getGlobalState("dismissedUpsells") || [] await provider.postMessageToWebview({ type: "dismissedUpsells", list: dismissedUpsells, }) break } case "openMarkdownPreview": { if (message.text) { try { const tmpDir = os.tmpdir() const timestamp = Date.now() const tempFileName = `roo-preview-${timestamp}.md` const tempFilePath = path.join(tmpDir, tempFileName) await fs.writeFile(tempFilePath, message.text, "utf8") const doc = await vscode.workspace.openTextDocument(tempFilePath) await vscode.commands.executeCommand("markdown.showPreview", doc.uri) } catch (error) { const errorMessage = error instanceof Error ? error.message : String(error) provider.log(`Error opening markdown preview: ${errorMessage}`) vscode.window.showErrorMessage(`Failed to open markdown preview: ${errorMessage}`) } } break } case "requestOpenAiCodexRateLimits": { try { const { openAiCodexOAuthManager } = await import("../../integrations/openai-codex/oauth") const accessToken = await openAiCodexOAuthManager.getAccessToken() if (!accessToken) { await provider.postMessageToWebview({ type: "openAiCodexRateLimits", error: "Not authenticated with OpenAI Codex", }) break } const accountId = await openAiCodexOAuthManager.getAccountId() const { fetchOpenAiCodexRateLimitInfo } = await import("../../integrations/openai-codex/rate-limits") const rateLimits = await fetchOpenAiCodexRateLimitInfo(accessToken, { accountId }) await provider.postMessageToWebview({ type: "openAiCodexRateLimits", values: rateLimits, }) } catch (error) { const errorMessage = error instanceof Error ? error.message : String(error) provider.log(`Error fetching OpenAI Codex rate limits: ${errorMessage}`) await provider.postMessageToWebview({ type: "openAiCodexRateLimits", error: errorMessage, }) } break } case "openDebugApiHistory": case "openDebugUiHistory": { const currentTask = provider.getCurrentTask() if (!currentTask) { vscode.window.showErrorMessage("No active task to view history for") break } try { const { getTaskDirectoryPath } = await import("../../utils/storage") const globalStoragePath = provider.contextProxy.globalStorageUri.fsPath const taskDirPath = await getTaskDirectoryPath(globalStoragePath, currentTask.taskId) const fileName = message.type === "openDebugApiHistory" ? "api_conversation_history.json" : "ui_messages.json" const sourceFilePath = path.join(taskDirPath, fileName) // Check if file exists if (!(await fileExistsAtPath(sourceFilePath))) { vscode.window.showErrorMessage(`File not found: ${fileName}`) break } // Read the source file const content = await fs.readFile(sourceFilePath, "utf8") let jsonContent: unknown try { jsonContent = JSON.parse(content) } catch { vscode.window.showErrorMessage(`Failed to parse ${fileName}`) break } // Prettify the JSON const prettifiedContent = JSON.stringify(jsonContent, null, 2) // Create a temporary file const tmpDir = os.tmpdir() const timestamp = Date.now() const tempFileName = `roo-debug-${message.type === "openDebugApiHistory" ? "api" : "ui"}-${currentTask.taskId.slice(0, 8)}-${timestamp}.json` const tempFilePath = path.join(tmpDir, tempFileName) await fs.writeFile(tempFilePath, prettifiedContent, "utf8") // Open the temp file in VS Code const doc = await vscode.workspace.openTextDocument(tempFilePath) await vscode.window.showTextDocument(doc, { preview: true }) } catch (error) { const errorMessage = error instanceof Error ? error.message : String(error) provider.log(`Error opening debug history: ${errorMessage}`) vscode.window.showErrorMessage(`Failed to open debug history: ${errorMessage}`) } break } case "downloadErrorDiagnostics": { const currentTask = provider.getCurrentTask() if (!currentTask) { vscode.window.showErrorMessage("No active task to generate diagnostics for") break } await generateErrorDiagnostics({ taskId: currentTask.taskId, globalStoragePath: provider.contextProxy.globalStorageUri.fsPath, values: message.values, log: (msg) => provider.log(msg), }) break } /** * Git Worktree Management */ case "listWorktrees": { try { const { worktrees, isGitRepo, isMultiRoot, isSubfolder, gitRootPath, error } = await handleListWorktrees(provider) await provider.postMessageToWebview({ type: "worktreeList", worktrees, isGitRepo, isMultiRoot, isSubfolder, gitRootPath, error, }) } catch (error) { const errorMessage = error instanceof Error ? error.message : String(error) await provider.postMessageToWebview({ type: "worktreeList", worktrees: [], isGitRepo: false, isMultiRoot: false, isSubfolder: false, gitRootPath: "", error: errorMessage, }) } break } case "createWorktree": { try { const { success, message: text } = await handleCreateWorktree( provider, { path: message.worktreePath!, branch: message.worktreeBranch, baseBranch: message.worktreeBaseBranch, createNewBranch: message.worktreeCreateNewBranch, }, (progress) => { void provider.postMessageToWebview({ type: "worktreeCopyProgress", copyProgressBytesCopied: progress.bytesCopied, copyProgressItemName: progress.itemName, }) }, ) await provider.postMessageToWebview({ type: "worktreeResult", success, text }) } catch (error) { const errorMessage = error instanceof Error ? error.message : String(error) await provider.postMessageToWebview({ type: "worktreeResult", success: false, text: errorMessage }) } break } case "deleteWorktree": { try { const { success, message: text } = await handleDeleteWorktree( provider, message.worktreePath!, message.worktreeForce ?? false, ) await provider.postMessageToWebview({ type: "worktreeResult", success, text }) } catch (error) { const errorMessage = error instanceof Error ? error.message : String(error) await provider.postMessageToWebview({ type: "worktreeResult", success: false, text: errorMessage }) } break } case "switchWorktree": { try { const { success, message: text } = await handleSwitchWorktree( provider, message.worktreePath!, message.worktreeNewWindow ?? true, ) await provider.postMessageToWebview({ type: "worktreeResult", success, text }) } catch (error) { const errorMessage = error instanceof Error ? error.message : String(error) await provider.postMessageToWebview({ type: "worktreeResult", success: false, text: errorMessage }) } break } case "getAvailableBranches": { try { const { localBranches, remoteBranches, currentBranch } = await handleGetAvailableBranches(provider) await provider.postMessageToWebview({ type: "branchList", localBranches, remoteBranches, currentBranch, }) } catch (error) { const errorMessage = error instanceof Error ? error.message : String(error) await provider.postMessageToWebview({ type: "branchList", localBranches: [], remoteBranches: [], currentBranch: "", error: errorMessage, }) } break } case "getWorktreeDefaults": { try { const { suggestedBranch, suggestedPath } = await handleGetWorktreeDefaults(provider) await provider.postMessageToWebview({ type: "worktreeDefaults", suggestedBranch, suggestedPath }) } catch (error) { const errorMessage = error instanceof Error ? error.message : String(error) await provider.postMessageToWebview({ type: "worktreeDefaults", suggestedBranch: "", suggestedPath: "", error: errorMessage, }) } break } case "getWorktreeIncludeStatus": { try { const worktreeIncludeStatus = await handleGetWorktreeIncludeStatus(provider) await provider.postMessageToWebview({ type: "worktreeIncludeStatus", worktreeIncludeStatus }) } catch (error) { const errorMessage = error instanceof Error ? error.message : String(error) await provider.postMessageToWebview({ type: "worktreeIncludeStatus", worktreeIncludeStatus: { exists: false, hasGitignore: false, gitignoreContent: undefined, }, error: errorMessage, }) } break } case "checkBranchWorktreeInclude": { try { const branch = message.worktreeBranch if (!branch) { await provider.postMessageToWebview({ type: "branchWorktreeIncludeResult", hasWorktreeInclude: false, error: "No branch specified", }) break } const hasWorktreeInclude = await handleCheckBranchWorktreeInclude(provider, branch) await provider.postMessageToWebview({ type: "branchWorktreeIncludeResult", branch, hasWorktreeInclude, }) } catch (error) { const errorMessage = error instanceof Error ? error.message : String(error) await provider.postMessageToWebview({ type: "branchWorktreeIncludeResult", hasWorktreeInclude: false, error: errorMessage, }) } break } case "createWorktreeInclude": { try { const { success, message: text } = await handleCreateWorktreeInclude( provider, message.worktreeIncludeContent ?? "", ) await provider.postMessageToWebview({ type: "worktreeResult", success, text }) } catch (error) { const errorMessage = error instanceof Error ? error.message : String(error) provider.log(`Error creating worktree include: ${errorMessage}`) await provider.postMessageToWebview({ type: "worktreeResult", success: false, text: errorMessage }) } break } case "checkoutBranch": { try { const { success, message: text } = await handleCheckoutBranch(provider, message.worktreeBranch!) await provider.postMessageToWebview({ type: "worktreeResult", success, text }) } catch (error) { const errorMessage = error instanceof Error ? error.message : String(error) await provider.postMessageToWebview({ type: "worktreeResult", success: false, text: errorMessage }) } break } case "browseForWorktreePath": { try { const options: vscode.OpenDialogOptions = { canSelectFiles: false, canSelectFolders: true, canSelectMany: false, openLabel: t("worktrees:selectWorktreeLocation"), title: t("worktrees:selectFolderForWorktree"), defaultUri: vscode.workspace.workspaceFolders?.[0]?.uri ? vscode.Uri.joinPath(vscode.workspace.workspaceFolders[0].uri, "..") : undefined, } const result = await vscode.window.showOpenDialog(options) if (result && result[0]) { await provider.postMessageToWebview({ type: "folderSelected", path: result[0].fsPath, }) } } catch (error) { const errorMessage = error instanceof Error ? error.message : String(error) provider.log(`Error opening folder picker: ${errorMessage}`) } break } default: { // console.log(`Unhandled message type: ${message.type}`) // // Currently unhandled: // // "currentApiConfigName" | // "codebaseIndexEnabled" | // "enhancedPrompt" | // "systemPrompt" | // "exportModeResult" | // "importModeResult" | // "checkRulesDirectoryResult" | // "browserConnectionResult" | // "vsCodeSetting" | // "indexingStatusUpdate" | // "indexCleared" | // "marketplaceInstallResult" | // "shareTaskSuccess" | // "playSound" | // "draggedImages" | // "setApiConfigPassword" | // "setopenAiCustomModelInfo" | // "marketplaceButtonClicked" | // "cancelMarketplaceInstall" | // "imageGenerationSettings" break } } }