feat: register importSettings as VSCode command (#5095)

Co-authored-by: Claude <[email protected]>
Co-authored-by: Daniel Riccio <[email protected]>

Author: 3 people

packages/types/src/vscode.ts

@@ -48,6 +48,7 @@ export const commandIds = [
 	"newTask",
 
 	"setCustomStoragePath",
+	"importSettings",
 
 	"focusInput",
 	"acceptInput",

src/activate/registerCommands.ts

@@ -13,6 +13,8 @@ import { focusPanel } from "../utils/focusPanel"
 import { registerHumanRelayCallback, unregisterHumanRelayCallback, handleHumanRelayResponse } from "./humanRelay"
 import { handleNewTask } from "./handleTask"
 import { CodeIndexManager } from "../services/code-index/manager"
+import { importSettingsWithFeedback } from "../core/config/importExport"
+import { t } from "../i18n"
 
 /**
  * Helper to get the visible ClineProvider instance or log if not found.
@@ -171,6 +173,22 @@ const getCommandsMap = ({ context, outputChannel, provider }: RegisterCommandOpt
 		const { promptForCustomStoragePath } = await import("../utils/storage")
 		await promptForCustomStoragePath()
 	},
+	importSettings: async (filePath?: string) => {
+		const visibleProvider = getVisibleProviderOrLog(outputChannel)
+		if (!visibleProvider) {
+			return
+		}
+
+		await importSettingsWithFeedback(
+			{
+				providerSettingsManager: visibleProvider.providerSettingsManager,
+				contextProxy: visibleProvider.contextProxy,
+				customModesManager: visibleProvider.customModesManager,
+				provider: visibleProvider,
+			},
+			filePath,
+		)
+	},
 	focusInput: async () => {
 		try {
 			await focusPanel(tabPanel, sidebarPanel)

src/core/config/__tests__/importExport.spec.ts

@@ -8,7 +8,7 @@ import * as vscode from "vscode"
 import type { ProviderName } from "@roo-code/types"
 import { TelemetryService } from "@roo-code/telemetry"
 
-import { importSettings, exportSettings } from "../importExport"
+import { importSettings, importSettingsFromFile, importSettingsWithFeedback, exportSettings } from "../importExport"
 import { ProviderSettingsManager } from "../ProviderSettingsManager"
 import { ContextProxy } from "../ContextProxy"
 import { CustomModesManager } from "../CustomModesManager"
@@ -20,6 +20,8 @@ vi.mock("vscode", () => ({
 	window: {
 		showOpenDialog: vi.fn(),
 		showSaveDialog: vi.fn(),
+		showErrorMessage: vi.fn(),
+		showInformationMessage: vi.fn(),
 	},
 	Uri: {
 		file: vi.fn((filePath) => ({ fsPath: filePath })),
@@ -31,10 +33,20 @@ vi.mock("fs/promises", () => ({
 		readFile: vi.fn(),
 		mkdir: vi.fn(),
 		writeFile: vi.fn(),
+		access: vi.fn(),
+		constants: {
+			F_OK: 0,
+			R_OK: 4,
+		},
 	},
 	readFile: vi.fn(),
 	mkdir: vi.fn(),
 	writeFile: vi.fn(),
+	access: vi.fn(),
+	constants: {
+		F_OK: 0,
+		R_OK: 4,
+	},
 }))
 
 vi.mock("os", () => ({
@@ -96,7 +108,7 @@ describe("importExport", () => {
 				customModesManager: mockCustomModesManager,
 			})
 
-			expect(result).toEqual({ success: false })
+			expect(result).toEqual({ success: false, error: "User cancelled file selection" })
 
 			expect(vscode.window.showOpenDialog).toHaveBeenCalledWith({
 				filters: { JSON: ["json"] },
@@ -146,9 +158,12 @@ describe("importExport", () => {
 			expect(mockProviderSettingsManager.export).toHaveBeenCalled()
 
 			expect(mockProviderSettingsManager.import).toHaveBeenCalledWith({
-				...previousProviderProfiles,
 				currentApiConfigName: "test",
-				apiConfigs: { test: { apiProvider: "openai" as ProviderName, apiKey: "test-key", id: "test-id" } },
+				apiConfigs: {
+					default: { apiProvider: "anthropic" as ProviderName, id: "default-id" },
+					test: { apiProvider: "openai" as ProviderName, apiKey: "test-key", id: "test-id" },
+				},
+				modeApiConfigs: {},
 			})
 
 			expect(mockContextProxy.setValues).toHaveBeenCalledWith({ mode: "code", autoApprovalEnabled: true })
@@ -219,11 +234,12 @@ describe("importExport", () => {
 			expect(fs.readFile).toHaveBeenCalledWith("/mock/path/settings.json", "utf-8")
 			expect(mockProviderSettingsManager.export).toHaveBeenCalled()
 			expect(mockProviderSettingsManager.import).toHaveBeenCalledWith({
-				...previousProviderProfiles,
 				currentApiConfigName: "test",
 				apiConfigs: {
+					default: { apiProvider: "anthropic" as ProviderName, id: "default-id" },
 					test: { apiProvider: "openai" as ProviderName, apiKey: "test-key", id: "test-id" },
 				},
+				modeApiConfigs: {},
 			})
 
 			// Should call setValues with an empty object since globalSettings is missing.
@@ -297,9 +313,11 @@ describe("importExport", () => {
 			})
 
 			expect(result.success).toBe(true)
-			expect(result.providerProfiles?.apiConfigs["openai"]).toBeDefined()
-			expect(result.providerProfiles?.apiConfigs["default"]).toBeDefined()
-			expect(result.providerProfiles?.apiConfigs["default"].apiProvider).toBe("anthropic")
+			if (result.success && "providerProfiles" in result) {
+				expect(result.providerProfiles?.apiConfigs["openai"]).toBeDefined()
+				expect(result.providerProfiles?.apiConfigs["default"]).toBeDefined()
+				expect(result.providerProfiles?.apiConfigs["default"].apiProvider).toBe("anthropic")
+			}
 		})
 
 		it("should call updateCustomMode for each custom mode in config", async () => {
@@ -337,6 +355,87 @@ describe("importExport", () => {
 				expect(mockCustomModesManager.updateCustomMode).toHaveBeenCalledWith(mode.slug, mode)
 			})
 		})
+
+		it("should import settings from provided file path without showing dialog", async () => {
+			const filePath = "/mock/path/settings.json"
+			const mockFileContent = JSON.stringify({
+				providerProfiles: {
+					currentApiConfigName: "test",
+					apiConfigs: { test: { apiProvider: "openai" as ProviderName, apiKey: "test-key", id: "test-id" } },
+				},
+				globalSettings: { mode: "code", autoApprovalEnabled: true },
+			})
+
+			;(fs.readFile as Mock).mockResolvedValue(mockFileContent)
+			;(fs.access as Mock).mockResolvedValue(undefined) // File exists and is readable
+
+			const previousProviderProfiles = {
+				currentApiConfigName: "default",
+				apiConfigs: { default: { apiProvider: "anthropic" as ProviderName, id: "default-id" } },
+			}
+
+			mockProviderSettingsManager.export.mockResolvedValue(previousProviderProfiles)
+			mockProviderSettingsManager.listConfig.mockResolvedValue([
+				{ name: "test", id: "test-id", apiProvider: "openai" as ProviderName },
+				{ name: "default", id: "default-id", apiProvider: "anthropic" as ProviderName },
+			])
+			mockContextProxy.export.mockResolvedValue({ mode: "code" })
+
+			const result = await importSettingsFromFile(
+				{
+					providerSettingsManager: mockProviderSettingsManager,
+					contextProxy: mockContextProxy,
+					customModesManager: mockCustomModesManager,
+				},
+				vscode.Uri.file(filePath),
+			)
+
+			expect(vscode.window.showOpenDialog).not.toHaveBeenCalled()
+			expect(fs.readFile).toHaveBeenCalledWith(filePath, "utf-8")
+			expect(result.success).toBe(true)
+			expect(mockProviderSettingsManager.import).toHaveBeenCalledWith({
+				currentApiConfigName: "test",
+				apiConfigs: {
+					default: { apiProvider: "anthropic" as ProviderName, id: "default-id" },
+					test: { apiProvider: "openai" as ProviderName, apiKey: "test-key", id: "test-id" },
+				},
+				modeApiConfigs: {},
+			})
+			expect(mockContextProxy.setValues).toHaveBeenCalledWith({ mode: "code", autoApprovalEnabled: true })
+		})
+
+		it("should return error when provided file path does not exist", async () => {
+			const filePath = "/nonexistent/path/settings.json"
+			const accessError = new Error("ENOENT: no such file or directory")
+
+			;(fs.access as Mock).mockRejectedValue(accessError)
+
+			// Create a mock provider for the test
+			const mockProvider = {
+				settingsImportedAt: 0,
+				postStateToWebview: vi.fn().mockResolvedValue(undefined),
+			}
+
+			// Mock the showErrorMessage to capture the error
+			const showErrorMessageSpy = vi.spyOn(vscode.window, "showErrorMessage").mockResolvedValue(undefined)
+
+			await importSettingsWithFeedback(
+				{
+					providerSettingsManager: mockProviderSettingsManager,
+					contextProxy: mockContextProxy,
+					customModesManager: mockCustomModesManager,
+					provider: mockProvider,
+				},
+				filePath,
+			)
+
+			expect(vscode.window.showOpenDialog).not.toHaveBeenCalled()
+			expect(fs.access).toHaveBeenCalledWith(filePath, fs.constants.F_OK | fs.constants.R_OK)
+			expect(fs.readFile).not.toHaveBeenCalled()
+			expect(showErrorMessageSpy).toHaveBeenCalledWith(expect.stringContaining("errors.settings_import_failed"))
+
+			showErrorMessageSpy.mockRestore()
+		})
 	})
 
 	describe("exportSettings", () => {

src/core/config/importExport.ts

@@ -12,6 +12,7 @@ import { TelemetryService } from "@roo-code/telemetry"
 import { ProviderSettingsManager, providerProfilesSchema } from "./ProviderSettingsManager"
 import { ContextProxy } from "./ContextProxy"
 import { CustomModesManager } from "./CustomModesManager"
+import { t } from "../../i18n"
 
 type ImportOptions = {
 	providerSettingsManager: ProviderSettingsManager
@@ -24,16 +25,41 @@ type ExportOptions = {
 	contextProxy: ContextProxy
 }
 
+type ImportWithProviderOptions = ImportOptions & {
+	provider: {
+		settingsImportedAt?: number
+		postStateToWebview: () => Promise<void>
+	}
+}
+
+/**
+ * Import settings from a file using a file dialog
+ * @param options - Import options containing managers and proxy
+ * @returns Promise resolving to import result
+ */
 export const importSettings = async ({ providerSettingsManager, contextProxy, customModesManager }: ImportOptions) => {
 	const uris = await vscode.window.showOpenDialog({
 		filters: { JSON: ["json"] },
 		canSelectMany: false,
 	})
 
 	if (!uris) {
-		return { success: false }
+		return { success: false, error: "User cancelled file selection" }
 	}
 
+	return await importSettingsFromFile({ providerSettingsManager, contextProxy, customModesManager }, uris[0])
+}
+
+/**
+ * Import settings from a specific file
+ * @param options - Import options containing managers and proxy
+ * @param fileUri - URI of the file to import from
+ * @returns Promise resolving to import result
+ */
+export const importSettingsFromFile = async (
+	{ providerSettingsManager, contextProxy, customModesManager }: ImportOptions,
+	fileUri: vscode.Uri,
+) => {
 	const schema = z.object({
 		providerProfiles: providerProfilesSchema,
 		globalSettings: globalSettingsSchema.optional(),
@@ -42,7 +68,7 @@ export const importSettings = async ({ providerSettingsManager, contextProxy, cu
 	try {
 		const previousProviderProfiles = await providerSettingsManager.export()
 
-		const data = JSON.parse(await fs.readFile(uris[0].fsPath, "utf-8"))
+		const data = JSON.parse(await fs.readFile(fileUri.fsPath, "utf-8"))
 		const { providerProfiles: newProviderProfiles, globalSettings = {} } = schema.parse(data)
 
 		const providerProfiles = {
@@ -61,7 +87,7 @@ export const importSettings = async ({ providerSettingsManager, contextProxy, cu
 			(globalSettings.customModes ?? []).map((mode) => customModesManager.updateCustomMode(mode.slug, mode)),
 		)
 
-		await providerSettingsManager.import(newProviderProfiles)
+		await providerSettingsManager.import(providerProfiles)
 		await contextProxy.setValues(globalSettings)
 
 		// Set the current provider.
@@ -120,3 +146,44 @@ export const exportSettings = async ({ providerSettingsManager, contextProxy }:
 		await safeWriteJson(uri.fsPath, { providerProfiles, globalSettings })
 	} catch (e) {}
 }
+
+/**
+ * Import settings with complete UI feedback and provider state updates
+ * @param options - Import options with provider instance
+ * @param filePath - Optional file path to import from. If not provided, a file dialog will be shown.
+ * @returns Promise that resolves when import is complete
+ */
+export const importSettingsWithFeedback = async (
+	{ providerSettingsManager, contextProxy, customModesManager, provider }: ImportWithProviderOptions,
+	filePath?: string,
+) => {
+	let result
+
+	if (filePath) {
+		// Validate file path and check if file exists
+		try {
+			const fileUri = vscode.Uri.file(filePath)
+			// Check if file exists and is readable
+			await fs.access(fileUri.fsPath, fs.constants.F_OK | fs.constants.R_OK)
+			result = await importSettingsFromFile(
+				{ providerSettingsManager, contextProxy, customModesManager },
+				fileUri,
+			)
+		} catch (error) {
+			result = {
+				success: false,
+				error: `Cannot access file at path "${filePath}": ${error instanceof Error ? error.message : "Unknown error"}`,
+			}
+		}
+	} else {
+		result = await importSettings({ providerSettingsManager, contextProxy, customModesManager })
+	}
+
+	if (result.success) {
+		provider.settingsImportedAt = Date.now()
+		await provider.postStateToWebview()
+		await vscode.window.showInformationMessage(t("common:info.settings_imported"))
+	} else if (result.error) {
+		await vscode.window.showErrorMessage(t("common:errors.settings_import_failed", { error: result.error }))
+	}
+}

src/core/webview/webviewMessageHandler.ts

@@ -28,7 +28,7 @@ import { fileExistsAtPath } from "../../utils/fs"
 import { playTts, setTtsEnabled, setTtsSpeed, stopTts } from "../../utils/tts"
 import { singleCompletionHandler } from "../../utils/single-completion-handler"
 import { searchCommits } from "../../utils/git"
-import { exportSettings, importSettings } from "../config/importExport"
+import { exportSettings, importSettingsWithFeedback } from "../config/importExport"
 import { getOpenAiModels } from "../../api/providers/openai"
 import { getVsCodeLmModels } from "../../api/providers/vscode-lm"
 import { openMention } from "../mentions"
@@ -325,20 +325,13 @@ export const webviewMessageHandler = async (
 			provider.exportTaskWithId(message.text!)
 			break
 		case "importSettings": {
-			const result = await importSettings({
+			await importSettingsWithFeedback({
 				providerSettingsManager: provider.providerSettingsManager,
 				contextProxy: provider.contextProxy,
 				customModesManager: provider.customModesManager,
+				provider: provider,
 			})
 
-			if (result.success) {
-				provider.settingsImportedAt = Date.now()
-				await provider.postStateToWebview()
-				await vscode.window.showInformationMessage(t("common:info.settings_imported"))
-			} else if (result.error) {
-				await vscode.window.showErrorMessage(t("common:errors.settings_import_failed", { error: result.error }))
-			}
-
 			break
 		}
 		case "exportSettings":

src/package.json

@@ -155,6 +155,11 @@
 				"title": "%command.setCustomStoragePath.title%",
 				"category": "%configuration.title%"
 			},
+			{
+				"command": "roo-cline.importSettings",
+				"title": "%command.importSettings.title%",
+				"category": "%configuration.title%"
+			},
 			{
 				"command": "roo-cline.focusInput",
 				"title": "%command.focusInput.title%",

src/package.nls.ca.json

@@ -9,6 +9,7 @@
 	"command.openInNewTab.title": "Obrir en una Nova Pestanya",
 	"command.focusInput.title": "Enfocar Camp d'Entrada",
 	"command.setCustomStoragePath.title": "Establir Ruta d'Emmagatzematge Personalitzada",
+	"command.importSettings.title": "Importar Configuració",
 	"command.terminal.addToContext.title": "Afegir Contingut del Terminal al Context",
 	"command.terminal.fixCommand.title": "Corregir Aquesta Ordre",
 	"command.terminal.explainCommand.title": "Explicar Aquesta Ordre",

src/package.nls.de.json

@@ -9,6 +9,7 @@
 	"command.openInNewTab.title": "In Neuem Tab Öffnen",
 	"command.focusInput.title": "Eingabefeld Fokussieren",
 	"command.setCustomStoragePath.title": "Benutzerdefinierten Speicherpfad Festlegen",
+	"command.importSettings.title": "Einstellungen Importieren",
 	"command.terminal.addToContext.title": "Terminal-Inhalt zum Kontext Hinzufügen",
 	"command.terminal.fixCommand.title": "Diesen Befehl Reparieren",
 	"command.terminal.explainCommand.title": "Diesen Befehl Erklären",