Strongly type our settings use composition where possible

Author: cte

src/core/Cline.ts

@@ -994,7 +994,7 @@ export class Cline extends EventEmitter<ClineEvents> {
 			}
 		}
 
-		const { terminalOutputLineLimit } = (await this.providerRef.deref()?.getState()) ?? {}
+		const { terminalOutputLineLimit = 500 } = (await this.providerRef.deref()?.getState()) ?? {}
 
 		process.on("line", (line) => {
 			if (!didContinue) {
@@ -2339,7 +2339,7 @@ export class Cline extends EventEmitter<ClineEvents> {
 								}
 
 								// Get the maxReadFileLine setting
-								const { maxReadFileLine } = (await this.providerRef.deref()?.getState()) ?? {}
+								const { maxReadFileLine = 500 } = (await this.providerRef.deref()?.getState()) ?? {}
 
 								// Count total lines in the file
 								let totalLines = 0
@@ -2480,13 +2480,14 @@ export class Cline extends EventEmitter<ClineEvents> {
 								this.consecutiveMistakeCount = 0
 								const absolutePath = path.resolve(this.cwd, relDirPath)
 								const [files, didHitLimit] = await listFiles(absolutePath, recursive, 200)
-								const { showRooIgnoredFiles } = (await this.providerRef.deref()?.getState()) ?? {}
+								const { showRooIgnoredFiles = true } =
+									(await this.providerRef.deref()?.getState()) ?? {}
 								const result = formatResponse.formatFilesList(
 									absolutePath,
 									files,
 									didHitLimit,
 									this.rooIgnoreController,
-									showRooIgnoredFiles ?? true,
+									showRooIgnoredFiles,
 								)
 								const completeMessage = JSON.stringify({
 									...sharedMessageProps,
@@ -3759,15 +3760,16 @@ export class Cline extends EventEmitter<ClineEvents> {
 	async getEnvironmentDetails(includeFileDetails: boolean = false) {
 		let details = ""
 
-		const { terminalOutputLineLimit, maxWorkspaceFiles } = (await this.providerRef.deref()?.getState()) ?? {}
+		const { terminalOutputLineLimit = 500, maxWorkspaceFiles = 200 } =
+			(await this.providerRef.deref()?.getState()) ?? {}
 
 		// It could be useful for cline to know if the user went from one or no file to another between messages, so we always include this context
 		details += "\n\n# VSCode Visible Files"
 		const visibleFilePaths = vscode.window.visibleTextEditors
 			?.map((editor) => editor.document?.uri?.fsPath)
 			.filter(Boolean)
 			.map((absolutePath) => path.relative(this.cwd, absolutePath))
-			.slice(0, maxWorkspaceFiles ?? 200)
+			.slice(0, maxWorkspaceFiles)
 
 		// Filter paths through rooIgnoreController
 		const allowedVisibleFiles = this.rooIgnoreController
@@ -3979,7 +3981,7 @@ export class Cline extends EventEmitter<ClineEvents> {
 			} else {
 				const maxFiles = maxWorkspaceFiles ?? 200
 				const [files, didHitLimit] = await listFiles(this.cwd, true, maxFiles)
-				const { showRooIgnoredFiles } = (await this.providerRef.deref()?.getState()) ?? {}
+				const { showRooIgnoredFiles = true } = (await this.providerRef.deref()?.getState()) ?? {}
 				const result = formatResponse.formatFilesList(
 					this.cwd,
 					files,

src/core/__tests__/contextProxy.test.ts

@@ -1,10 +1,12 @@
 // npx jest src/core/__tests__/contextProxy.test.ts
 
+import fs from "fs/promises"
+
 import * as vscode from "vscode"
 import { ContextProxy } from "../contextProxy"
 
 import { logger } from "../../utils/logging"
-import { GLOBAL_STATE_KEYS, SECRET_KEYS, ConfigurationKey, GlobalStateKey } from "../../shared/globalState"
+import { GLOBAL_STATE_KEYS, SECRET_STATE_KEYS } from "../../shared/globalState"
 
 jest.mock("vscode", () => ({
 	Uri: {
@@ -77,8 +79,8 @@ describe("ContextProxy", () => {
 		})
 
 		it("should initialize secret cache with all secret keys", () => {
-			expect(mockSecrets.get).toHaveBeenCalledTimes(SECRET_KEYS.length)
-			for (const key of SECRET_KEYS) {
+			expect(mockSecrets.get).toHaveBeenCalledTimes(SECRET_STATE_KEYS.length)
+			for (const key of SECRET_STATE_KEYS) {
 				expect(mockSecrets.get).toHaveBeenCalledWith(key)
 			}
 		})
@@ -87,28 +89,28 @@ describe("ContextProxy", () => {
 	describe("getGlobalState", () => {
 		it("should return value from cache when it exists", async () => {
 			// Manually set a value in the cache
-			await proxy.updateGlobalState("apiProvider", "cached-value")
+			await proxy.updateGlobalState("apiProvider", "deepseek")
 
 			// Should return the cached value
 			const result = proxy.getGlobalState("apiProvider")
-			expect(result).toBe("cached-value")
+			expect(result).toBe("deepseek")
 
 			// Original context should be called once during updateGlobalState
 			expect(mockGlobalState.get).toHaveBeenCalledTimes(GLOBAL_STATE_KEYS.length) // Only from initialization
 		})
 
 		it("should handle default values correctly", async () => {
 			// No value in cache
-			const result = proxy.getGlobalState("apiProvider", "default-value")
-			expect(result).toBe("default-value")
+			const result = proxy.getGlobalState("apiProvider", "deepseek")
+			expect(result).toBe("deepseek")
 		})
 
 		it("should bypass cache for pass-through state keys", async () => {
 			// Setup mock return value
 			mockGlobalState.get.mockReturnValue("pass-through-value")
 
 			// Use a pass-through key (taskHistory)
-			const result = proxy.getGlobalState("taskHistory" as GlobalStateKey)
+			const result = proxy.getGlobalState("taskHistory")
 
 			// Should get value directly from original context
 			expect(result).toBe("pass-through-value")
@@ -120,37 +122,61 @@ describe("ContextProxy", () => {
 			mockGlobalState.get.mockReturnValue(undefined)
 
 			// Use a pass-through key with default value
-			const result = proxy.getGlobalState("taskHistory" as GlobalStateKey, "default-value")
+			const historyItems = [
+				{
+					id: "1",
+					number: 1,
+					ts: 1,
+					task: "test",
+					tokensIn: 1,
+					tokensOut: 1,
+					totalCost: 1,
+				},
+			]
+
+			const result = proxy.getGlobalState("taskHistory", historyItems)
 
 			// Should return default value when original context returns undefined
-			expect(result).toBe("default-value")
+			expect(result).toBe(historyItems)
 		})
 	})
 
 	describe("updateGlobalState", () => {
 		it("should update state directly in original context", async () => {
-			await proxy.updateGlobalState("apiProvider", "new-value")
+			await proxy.updateGlobalState("apiProvider", "deepseek")
 
 			// Should have called original context
-			expect(mockGlobalState.update).toHaveBeenCalledWith("apiProvider", "new-value")
+			expect(mockGlobalState.update).toHaveBeenCalledWith("apiProvider", "deepseek")
 
 			// Should have stored the value in cache
 			const storedValue = await proxy.getGlobalState("apiProvider")
-			expect(storedValue).toBe("new-value")
+			expect(storedValue).toBe("deepseek")
 		})
 
 		it("should bypass cache for pass-through state keys", async () => {
-			await proxy.updateGlobalState("taskHistory" as GlobalStateKey, "new-value")
+			const historyItems = [
+				{
+					id: "1",
+					number: 1,
+					ts: 1,
+					task: "test",
+					tokensIn: 1,
+					tokensOut: 1,
+					totalCost: 1,
+				},
+			]
+
+			await proxy.updateGlobalState("taskHistory", historyItems)
 
 			// Should update original context
-			expect(mockGlobalState.update).toHaveBeenCalledWith("taskHistory", "new-value")
+			expect(mockGlobalState.update).toHaveBeenCalledWith("taskHistory", historyItems)
 
 			// Setup mock for subsequent get
-			mockGlobalState.get.mockReturnValue("new-value")
+			mockGlobalState.get.mockReturnValue(historyItems)
 
 			// Should get fresh value from original context
-			const storedValue = proxy.getGlobalState("taskHistory" as GlobalStateKey)
-			expect(storedValue).toBe("new-value")
+			const storedValue = proxy.getGlobalState("taskHistory")
+			expect(storedValue).toBe(historyItems)
 			expect(mockGlobalState.get).toHaveBeenCalledWith("taskHistory")
 		})
 	})
@@ -220,27 +246,6 @@ describe("ContextProxy", () => {
 			const storedValue = proxy.getGlobalState("apiModelId")
 			expect(storedValue).toBe("gpt-4")
 		})
-
-		it("should handle unknown keys as global state with warning", async () => {
-			// Spy on the logger
-			const warnSpy = jest.spyOn(logger, "warn")
-
-			// Spy on updateGlobalState
-			const updateGlobalStateSpy = jest.spyOn(proxy, "updateGlobalState")
-
-			// Test with an unknown key
-			await proxy.setValue("unknownKey" as ConfigurationKey, "some-value")
-
-			// Should have logged a warning
-			expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("Unknown key: unknownKey"))
-
-			// Should have called updateGlobalState
-			expect(updateGlobalStateSpy).toHaveBeenCalledWith("unknownKey", "some-value")
-
-			// Should have stored the value in state cache
-			const storedValue = proxy.getGlobalState("unknownKey" as GlobalStateKey)
-			expect(storedValue).toBe("some-value")
-		})
 	})
 
 	describe("setValues", () => {
@@ -288,7 +293,7 @@ describe("ContextProxy", () => {
 		})
 	})
 
-	describe("setApiConfiguration", () => {
+	describe("setProviderSettings", () => {
 		it("should clear old API configuration values and set new ones", async () => {
 			// Set up initial API configuration values
 			await proxy.updateGlobalState("apiModelId", "old-model")
@@ -298,8 +303,8 @@ describe("ContextProxy", () => {
 			// Spy on setValues
 			const setValuesSpy = jest.spyOn(proxy, "setValues")
 
-			// Call setApiConfiguration with new configuration
-			await proxy.setApiConfiguration({
+			// Call setProviderSettings with new configuration
+			await proxy.setProviderSettings({
 				apiModelId: "new-model",
 				apiProvider: "anthropic",
 				// Note: openAiBaseUrl is not included in the new config
@@ -332,8 +337,8 @@ describe("ContextProxy", () => {
 			// Spy on setValues
 			const setValuesSpy = jest.spyOn(proxy, "setValues")
 
-			// Call setApiConfiguration with empty configuration
-			await proxy.setApiConfiguration({})
+			// Call setProviderSettings with empty configuration
+			await proxy.setProviderSettings({})
 
 			// Verify setValues was called with undefined for all existing API config keys
 			expect(setValuesSpy).toHaveBeenCalledWith(
@@ -397,12 +402,12 @@ describe("ContextProxy", () => {
 			await proxy.resetAllState()
 
 			// Should have called delete for each key
-			for (const key of SECRET_KEYS) {
+			for (const key of SECRET_STATE_KEYS) {
 				expect(mockSecrets.delete).toHaveBeenCalledWith(key)
 			}
 
 			// Total calls should equal the number of secret keys
-			expect(mockSecrets.delete).toHaveBeenCalledTimes(SECRET_KEYS.length)
+			expect(mockSecrets.delete).toHaveBeenCalledTimes(SECRET_STATE_KEYS.length)
 		})
 
 		it("should reinitialize caches after reset", async () => {
@@ -416,4 +421,88 @@ describe("ContextProxy", () => {
 			expect(initializeSpy).toHaveBeenCalledTimes(1)
 		})
 	})
+
+	describe("exportGlobalSettings", () => {
+		it("should write global settings to a file when filePath is provided", async () => {
+			await proxy.setValues({
+				apiModelId: "gpt-4",
+				apiProvider: "openai",
+				openAiApiKey: "test-api-key",
+				autoApprovalEnabled: true,
+			})
+
+			const filePath = `/tmp/roo-global-config-${Date.now()}.json`
+			const result = await proxy.exportGlobalSettings(filePath)
+			expect(result).toEqual({ autoApprovalEnabled: true })
+			const fileContent = await fs.readFile(filePath, "utf-8")
+			expect(fileContent).toContain('"autoApprovalEnabled": true')
+
+			await proxy.setValue("autoApprovalEnabled", false)
+			expect(proxy.getValue("autoApprovalEnabled")).toBe(false)
+
+			const importedConfig = await proxy.importGlobalSettings(filePath)
+			expect(importedConfig).toEqual({ autoApprovalEnabled: true })
+			expect(proxy.getValue("autoApprovalEnabled")).toBe(true)
+
+			await fs.unlink(filePath)
+		})
+	})
+
+	describe("exportProviderSettings", () => {
+		it("should write provider settings to a file when filePath is provided", async () => {
+			await proxy.setValues({
+				apiModelId: "gpt-4",
+				apiProvider: "openai",
+				openAiApiKey: "test-api-key",
+				autoApprovalEnabled: true,
+			})
+
+			const filePath = `/tmp/roo-api-config-${Date.now()}.json`
+			const result = await proxy.exportProviderSettings(filePath)
+			expect(result).toEqual({
+				apiModelId: "gpt-4",
+				apiProvider: "openai",
+				openAiApiKey: "test-api-key",
+				apiKey: "test-secret",
+				awsAccessKey: "test-secret",
+				awsSecretKey: "test-secret",
+				awsSessionToken: "test-secret",
+				deepSeekApiKey: "test-secret",
+				geminiApiKey: "test-secret",
+				glamaApiKey: "test-secret",
+				mistralApiKey: "test-secret",
+				openAiNativeApiKey: "test-secret",
+				openRouterApiKey: "test-secret",
+				requestyApiKey: "test-secret",
+				unboundApiKey: "test-secret",
+			})
+			const fileContent = await fs.readFile(filePath, "utf-8")
+			expect(fileContent).toContain('"openAiApiKey": "test-api-key"')
+
+			await proxy.setValue("openAiApiKey", "new-test-api-key")
+			expect(proxy.getValue("openAiApiKey")).toBe("new-test-api-key")
+
+			const importedConfig = await proxy.importProviderSettings(filePath)
+			expect(importedConfig).toEqual({
+				apiModelId: "gpt-4",
+				apiProvider: "openai",
+				openAiApiKey: "test-api-key",
+				apiKey: "test-secret",
+				awsAccessKey: "test-secret",
+				awsSecretKey: "test-secret",
+				awsSessionToken: "test-secret",
+				deepSeekApiKey: "test-secret",
+				geminiApiKey: "test-secret",
+				glamaApiKey: "test-secret",
+				mistralApiKey: "test-secret",
+				openAiNativeApiKey: "test-secret",
+				openRouterApiKey: "test-secret",
+				requestyApiKey: "test-secret",
+				unboundApiKey: "test-secret",
+			})
+			expect(proxy.getValue("openAiApiKey")).toBe("test-api-key")
+
+			await fs.unlink(filePath)
+		})
+	})
 })

src/core/config/ConfigManager.ts

@@ -6,7 +6,7 @@ import { ApiConfigMeta } from "../../shared/ExtensionMessage"
 export interface ApiConfigData {
 	currentApiConfigName: string
 	apiConfigs: {
-		[key: string]: ApiConfiguration
+		[key: string]: ApiConfiguration & { id?: string }
 	}
 	modeApiConfigs?: Partial<Record<Mode, string>>
 }