feat: add VS Code Settings Sync integration

- Add enableSettingsSync configuration option (default: true)
- Implement SettingsSyncService to manage sync key registration
- Register user preferences, modes, and non-sensitive settings for sync
- API keys remain in secure VS Code secrets storage (already synced)
- Add comprehensive tests for sync functionality
- Support opt-in/opt-out via settings with automatic updates

Resolves: #2057

Author: Your Name

src/extension.ts

@@ -45,6 +45,7 @@ import { initializeI18n } from "./i18n"
 import { registerGhostProvider } from "./services/ghost" // kilocode_change
 import { TerminalWelcomeService } from "./services/terminal-welcome/TerminalWelcomeService" // kilocode_change
 import { getKiloCodeWrapperProperties } from "./core/kilocode/wrapper" // kilocode_change
+import { SettingsSyncService } from "./services/settings-sync/SettingsSyncService"
 
 /**
  * Built using https://github.com/microsoft/vscode-webview-ui-toolkit
@@ -313,6 +314,31 @@ export async function activate(context: vscode.ExtensionContext) {
 		)
 	}
 
+	// Initialize VS Code Settings Sync integration
+	try {
+		await SettingsSyncService.initialize(context)
+		outputChannel.appendLine("[SettingsSync] VS Code Settings Sync integration initialized")
+
+		// Listen for configuration changes to update sync registration
+		const configChangeListener = vscode.workspace.onDidChangeConfiguration(async (event) => {
+			if (event.affectsConfiguration(`${Package.name}.enableSettingsSync`)) {
+				try {
+					await SettingsSyncService.updateSyncRegistration(context)
+					outputChannel.appendLine("[SettingsSync] Sync registration updated due to configuration change")
+				} catch (error) {
+					outputChannel.appendLine(
+						`[SettingsSync] Error updating sync registration: ${error instanceof Error ? error.message : String(error)}`,
+					)
+				}
+			}
+		})
+		context.subscriptions.push(configChangeListener)
+	} catch (error) {
+		outputChannel.appendLine(
+			`[SettingsSync] Error during settings sync initialization: ${error instanceof Error ? error.message : String(error)}`,
+		)
+	}
+
 	registerCommands({ context, outputChannel, provider })
 
 	/**

src/package.json

@@ -585,6 +585,11 @@
 					"type": "boolean",
 					"default": false,
 					"description": "%settings.newTaskRequireTodos.description%"
+				},
+				"kilo-code.enableSettingsSync": {
+					"type": "boolean",
+					"default": true,
+					"description": "%settings.enableSettingsSync.description%"
 				}
 			}
 		},

src/package.nls.json

@@ -44,6 +44,7 @@
 	"settings.useAgentRules.description": "Enable loading of AGENTS.md files for agent-specific rules (see https://agent-rules.org/)",
 	"settings.apiRequestTimeout.description": "Maximum time in seconds to wait for API responses (0 = no timeout, 1-3600s, default: 600s). Higher values are recommended for local providers like LM Studio and Ollama that may need more processing time.",
 	"settings.newTaskRequireTodos.description": "Require todos parameter when creating new tasks with the new_task tool",
+	"settings.enableSettingsSync.description": "Enable synchronization of Kilo Code settings across devices via VS Code Settings Sync. When enabled, your API configurations, custom modes, and preferences will automatically sync when you sign in to VS Code Settings Sync.",
 	"ghost.input.title": "Press 'Enter' to confirm or 'Escape' to cancel",
 	"ghost.input.placeholder": "Describe what you want to do...",
 	"ghost.commands.generateSuggestions": "Generate Suggested Edits",

src/services/settings-sync/SettingsSyncService.ts

@@ -0,0 +1,57 @@
+import * as vscode from "vscode"
+import { Package } from "../../shared/package"
+
+/**
+ * Service for managing Kilo Code settings synchronization with VS Code Settings Sync
+ */
+export class SettingsSyncService {
+	// Keys from global state that should be synchronized
+	// Note: API keys are stored in VS Code secrets storage and are already sync'd by VS Code
+	private static readonly SYNC_KEYS = [
+		"allowedCommands",
+		"deniedCommands",
+		"autoApprovalEnabled",
+		"fuzzyMatchThreshold",
+		"diffEnabled",
+		"directoryContextAddedContext",
+		"language",
+		"customModes",
+		"firstInstallCompleted",
+		"telemetrySetting",
+	] as const
+
+	/**
+	 * Initialize settings synchronization
+	 * @param context VS Code extension context
+	 */
+	static async initialize(context: vscode.ExtensionContext): Promise<void> {
+		const enableSync = vscode.workspace.getConfiguration(Package.name).get<boolean>("enableSettingsSync", true)
+
+		if (enableSync) {
+			// Register keys for synchronization with VS Code Settings Sync
+			const syncKeys = this.SYNC_KEYS.map((key) => `${Package.name}.${key}`)
+			context.globalState.setKeysForSync(syncKeys)
+
+			console.log(`[SettingsSyncService] Registered ${syncKeys.length} keys for synchronization:`, syncKeys)
+		} else {
+			// Clear sync keys if sync is disabled
+			context.globalState.setKeysForSync([])
+			console.log(`[SettingsSyncService] Settings sync disabled - cleared sync keys`)
+		}
+	}
+
+	/**
+	 * Update sync registration when the setting changes
+	 * @param context VS Code extension context
+	 */
+	static async updateSyncRegistration(context: vscode.ExtensionContext): Promise<void> {
+		await this.initialize(context)
+	}
+
+	/**
+	 * Get the list of keys that are registered for sync
+	 */
+	static getSyncKeys(): readonly string[] {
+		return this.SYNC_KEYS.map((key) => `${Package.name}.${key}`)
+	}
+}

src/services/settings-sync/__tests__/SettingsSyncService.spec.ts

@@ -0,0 +1,108 @@
+import { describe, it, expect, vi, beforeEach } from "vitest"
+import * as vscode from "vscode"
+import { SettingsSyncService } from "../SettingsSyncService"
+
+// Mock VS Code API
+vi.mock("vscode", () => ({
+	workspace: {
+		getConfiguration: vi.fn(),
+	},
+}))
+
+describe("SettingsSyncService", () => {
+	let mockContext: vscode.ExtensionContext
+	let mockGlobalState: any
+
+	beforeEach(() => {
+		mockGlobalState = {
+			setKeysForSync: vi.fn(),
+		}
+
+		mockContext = {
+			globalState: mockGlobalState,
+		} as any
+
+		vi.clearAllMocks()
+	})
+
+	describe("initialize", () => {
+		it("should register sync keys when settings sync is enabled", async () => {
+			const mockConfiguration = {
+				get: vi.fn().mockReturnValue(true),
+			}
+			vi.mocked(vscode.workspace.getConfiguration).mockReturnValue(mockConfiguration as any)
+
+			await SettingsSyncService.initialize(mockContext)
+
+			expect(mockGlobalState.setKeysForSync).toHaveBeenCalledWith([
+				"kilo-code.allowedCommands",
+				"kilo-code.deniedCommands",
+				"kilo-code.autoApprovalEnabled",
+				"kilo-code.fuzzyMatchThreshold",
+				"kilo-code.diffEnabled",
+				"kilo-code.directoryContextAddedContext",
+				"kilo-code.language",
+				"kilo-code.customModes",
+				"kilo-code.firstInstallCompleted",
+				"kilo-code.telemetrySetting",
+			])
+		})
+
+		it("should clear sync keys when settings sync is disabled", async () => {
+			const mockConfiguration = {
+				get: vi.fn().mockReturnValue(false),
+			}
+			vi.mocked(vscode.workspace.getConfiguration).mockReturnValue(mockConfiguration as any)
+
+			await SettingsSyncService.initialize(mockContext)
+
+			expect(mockGlobalState.setKeysForSync).toHaveBeenCalledWith([])
+		})
+
+		it("should use default value true when setting is not configured", async () => {
+			const mockConfiguration = {
+				get: vi.fn().mockReturnValue(undefined),
+			}
+			vi.mocked(vscode.workspace.getConfiguration).mockReturnValue(mockConfiguration as any)
+
+			await SettingsSyncService.initialize(mockContext)
+
+			expect(mockConfiguration.get).toHaveBeenCalledWith("enableSettingsSync", true)
+			expect(mockGlobalState.setKeysForSync).toHaveBeenCalledWith(
+				expect.arrayContaining(["kilo-code.allowedCommands", "kilo-code.deniedCommands"]),
+			)
+		})
+	})
+
+	describe("updateSyncRegistration", () => {
+		it("should call initialize to update sync registration", async () => {
+			const mockConfiguration = {
+				get: vi.fn().mockReturnValue(false),
+			}
+			vi.mocked(vscode.workspace.getConfiguration).mockReturnValue(mockConfiguration as any)
+
+			await SettingsSyncService.updateSyncRegistration(mockContext)
+
+			expect(mockGlobalState.setKeysForSync).toHaveBeenCalledWith([])
+		})
+	})
+
+	describe("getSyncKeys", () => {
+		it("should return the list of sync keys", () => {
+			const syncKeys = SettingsSyncService.getSyncKeys()
+
+			expect(syncKeys).toEqual([
+				"kilo-code.allowedCommands",
+				"kilo-code.deniedCommands",
+				"kilo-code.autoApprovalEnabled",
+				"kilo-code.fuzzyMatchThreshold",
+				"kilo-code.diffEnabled",
+				"kilo-code.directoryContextAddedContext",
+				"kilo-code.language",
+				"kilo-code.customModes",
+				"kilo-code.firstInstallCompleted",
+				"kilo-code.telemetrySetting",
+			])
+		})
+	})
+})