feat(jetbrains): add Agent Behavior settings

.changeset/staged-agent-settings.md

@@ -0,0 +1,6 @@
+---
+"@kilocode/cli": patch
+"@kilocode/kilo-jetbrains": patch
+---
+
+Improve JetBrains agent, MCP, provider, and model settings so changes are staged until Apply, persist through the CLI, reload accurately, and hide unsupported removal actions.

packages/kilo-jetbrains/AGENTS.md

@@ -547,6 +547,7 @@ Official references:
 - [User Interface Components](https://plugins.jetbrains.com/docs/intellij/user-interface-components.html)
 - [UI FAQ (colors, borders, icons)](https://plugins.jetbrains.com/docs/intellij/ui-faq.html)
 
+- For compact icon-only actions, use `ai.kilocode.client.ui.HoverIcon` so the control gets the standard 24×24 hover treatment. Do not create `JButton(icon)` or wrap a bare icon in a button just to make it clickable.
 - **Reuse platform icons**: browse at https://intellij-icons.jetbrains.design. Access via `AllIcons.*` constants.
 - Custom icons: SVG files in `resources/icons/`. Load via `IconLoader.getIcon("/icons/foo.svg", MyClass::class.java)`.
 - Organize in an `icons` package or a `*Icons` object with `@JvmField` on each constant.
@@ -583,6 +584,38 @@ Review generated UI code and remove:
 - Extra helpers that do not make the UI clearer or more reusable
 - Any Kotlin UI DSL (`com.intellij.ui.dsl.builder`) introduced by accident
 
+## Settings UI
+
+Settings UI has reusable primitives in `frontend/src/main/kotlin/ai/kilocode/client/settings/base/`. Check these before adding new settings components or custom Swing assemblies.
+
+### Base Pages And Messaging
+
+- Use `BaseSettingsUi` for app-backed draft settings that need app-state collection, workspace loading/refreshing, draft/baseline tracking, save progress, save failure handling, and login/banner integration.
+- Use `SettingsPanel` and `SettingsOverlayPanel` as the settings surface so progress and errors go through `showProgress`, `updateProgress`, `showError`, and `clearProgress`.
+- Use `SettingsTop` for settings banners and login prompts rather than ad hoc labels, notifications, or dialog prompts embedded in the form.
+- Use `SettingsDraftState` and `SettingsDraftPage` for modified/reset/apply behavior instead of maintaining unrelated local dirty-state mechanisms.
+- Use the base loading and refresh flow (`BaseSettingsUi` or `SettingsListPanel.reload` / `mutateAndReload`) so busy state, refresh selection, and app readiness are handled consistently.
+- Communicate load, refresh, validation, and save errors through the common settings messaging mechanisms: overlay `showError`, `SettingsMessageException` for user-facing list mutation errors, `failedText()` / `saveError` in `BaseSettingsUi`, and `SettingsTop` banners for persistent page-level problems.
+
+### Rows And Forms
+
+- Use `SettingsRow`, `SettingsStackedRow`, and `SettingsRows` for reusable setting rows, stacked text/editing rows, keyed dynamic rows, and setting sections.
+- Do not create a custom row panel for each setting unless the common row classes cannot represent the behavior.
+- Keep settings UI on the EDT and continue using existing platform Swing components, `Stack`, `Align`, `UiStyle`, and localized `KiloBundle` strings according to the UI guidance above.
+
+### Lists And Add/Remove Collections
+
+- For add/remove/edit collections, use the shared list infrastructure: `SettingsListPanel`, `SettingsListView`, `SettingsListItem`, `SettingsListCell`, `SettingsListSelection`, and `SettingsToolbarAction` where applicable.
+- When a setting is a list of values that can be added or removed inline, represent it with common list/editor primitives, toolbar actions, and in-place cells/buttons as needed.
+- Do not build a bespoke set of Swing components for each add/remove list situation.
+- Prefer list action cells (`SettingsListCell`) for row-local actions like edit/delete and toolbar actions for global add/import/refresh actions.
+
+### Settings Test Coverage Pattern
+
+- Each settings page that writes state needs a fake-RPC frontend test that proves UI interactions call the expected client service/RPC method.
+- Each backend-backed settings write path needs a `*RpcApiImpl` or manager test against `MockCliServer` that asserts the exact CLI HTTP body and that a subsequent reload observes the persisted value.
+- Navigation-only settings pages should still have `BasePlatformTestCase` coverage for rendered child links, stable child IDs, and inert `isModified`/`apply` behavior.
+
 ## Session Component
 
 The chat session feature uses a three-layer Model / Controller / View architecture. All files live under

packages/kilo-jetbrains/backend/src/main/kotlin/ai/kilocode/backend/app/KiloAppState.kt

@@ -1,9 +1,9 @@
 package ai.kilocode.backend.app
 
-import ai.kilocode.jetbrains.api.model.Config
 import ai.kilocode.jetbrains.api.model.KiloNotifications200ResponseInner
 import ai.kilocode.jetbrains.api.model.KiloProfile200Response
 import ai.kilocode.backend.migration.LegacyMigrationDetection
+import ai.kilocode.rpc.dto.ConfigDto
 
 /**
  * Full application lifecycle state, combining CLI transport connection
@@ -54,7 +54,7 @@ data class ConfigWarning(
  */
 data class AppData(
     val profile: KiloProfile200Response?,
-    val config: Config,
+    val config: ConfigDto,
     val notifications: List<KiloNotifications200ResponseInner>,
     val warnings: List<ConfigWarning> = emptyList(),
 )

packages/kilo-jetbrains/backend/src/main/kotlin/ai/kilocode/backend/app/KiloBackendAppService.kt

@@ -13,12 +13,12 @@ import ai.kilocode.jetbrains.api.infrastructure.ClientError
 import ai.kilocode.jetbrains.api.infrastructure.ClientException
 import ai.kilocode.jetbrains.api.infrastructure.ServerError
 import ai.kilocode.jetbrains.api.infrastructure.ServerException
-import ai.kilocode.jetbrains.api.model.Config
 import ai.kilocode.jetbrains.api.model.ConfigWarnings200ResponseInner
 import ai.kilocode.jetbrains.api.model.KiloNotifications200ResponseInner
 import ai.kilocode.jetbrains.api.model.KiloProfile200Response
 import ai.kilocode.jetbrains.api.model.ProviderOauthAuthorizeRequest
 import ai.kilocode.jetbrains.api.model.ProviderOauthCallbackRequest
+import ai.kilocode.rpc.dto.ConfigDto
 import ai.kilocode.rpc.dto.DeviceAuthDto
 import ai.kilocode.rpc.dto.ConfigPatchDto
 import ai.kilocode.rpc.dto.HealthDto
@@ -39,6 +39,7 @@ import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.suspendCancellableCoroutine
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.withContext
 import kotlinx.coroutines.withTimeout
@@ -56,6 +57,8 @@ import java.net.ConnectException
 import java.net.SocketTimeoutException
 import java.util.concurrent.CopyOnWriteArrayList
 import java.util.concurrent.atomic.AtomicReference
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
 
 /**
  * App-level orchestrator that owns the CLI server lifecycle and
@@ -130,7 +133,7 @@ class KiloBackendAppService private constructor(
     @Volatile var profile: KiloProfile200Response? = null
         private set
 
-    @Volatile var config: Config? = null
+    @Volatile var config: ConfigDto? = null
         private set
 
     @Volatile var notifications: List<KiloNotifications200ResponseInner> = emptyList()
@@ -245,6 +248,7 @@ class KiloBackendAppService private constructor(
     suspend fun updateConfig(patch: ConfigPatchDto): KiloAppState {
         val http = connection.apiClient ?: throw IllegalStateException("Not connected")
         val current = _appState.value as? KiloAppState.Ready ?: throw IllegalStateException("Kilo backend is not ready")
+        val connected = connection.state.value as? ConnectionState.Connected
         val body = KiloCliDataParser.buildConfigPatch(patch)
         val summary = summary(patch)
         log.info("Global config patch: started $summary")
@@ -256,14 +260,23 @@ class KiloBackendAppService private constructor(
         withContext(Dispatchers.IO) {
             http.newCall(request).execute().use { response ->
                 if (!response.isSuccessful) {
-                    val text = response.body?.string()
-                    log.warn("Global config patch failed: HTTP ${response.code} ${response.message} $summary ${text.orEmpty()}")
+                    log.warn("Global config patch failed: HTTP ${response.code} ${response.message} $summary")
                     throw IllegalStateException("Global config patch failed: HTTP ${response.code} ${response.message}")
                 }
             }
         }
         log.info("Global config patch: saved $summary")
-        refreshConfigState()
+        val cfg = fetchConfig().value
+        if (cfg == null) {
+            log.warn("Global config patch: config reload failed after save $summary")
+            return (_appState.value as? KiloAppState.Ready) ?: current
+        }
+        val warns = fetchWarnings()
+        val state = _appState.value
+        if (state is KiloAppState.Ready && state.data === current.data && connection.state.value == connected) {
+            config = cfg
+            setAppReady(current.data.copy(config = cfg, warnings = warns))
+        }
         log.info("Global config patch: state refreshed $summary")
         return (_appState.value as? KiloAppState.Ready) ?: current
     }
@@ -342,7 +355,7 @@ class KiloBackendAppService private constructor(
                 }
 
                 val errors = CopyOnWriteArrayList<LoadError>()
-                var cfg: Config? = null
+                var cfg: ConfigDto? = null
                 var prof: KiloProfile200Response? = null
                 var notifs: List<KiloNotifications200ResponseInner> = emptyList()
                 var warns: List<ConfigWarning> = emptyList()
@@ -553,14 +566,39 @@ class KiloBackendAppService private constructor(
         }
     }
 
-    private suspend fun fetchConfig(): FetchResult<Config> {
-        val client = connection.appLoadApi
+    private suspend fun fetchConfig(): FetchResult<ConfigDto> {
+        val http = connection.apiClient
             ?: return FetchResult.fail("config", detail = "Not connected")
         return try {
-            FetchResult.ok(client.globalConfigGet())
+            val request = Request.Builder()
+                .url("http://127.0.0.1:$port/global/config")
+                .header("Accept", "application/json")
+                .get()
+                .build()
+            val body = withContext(Dispatchers.IO) {
+                suspendCancellableCoroutine { cont ->
+                    val call = http.newCall(request)
+                    cont.invokeOnCancellation { call.cancel() }
+                    try {
+                        val text = call.execute().use { response ->
+                            val text = response.body?.string().orEmpty()
+                            if (!response.isSuccessful) {
+                                log.warn("Global config fetch failed: HTTP ${response.code} ${response.message} $text")
+                                throw IllegalStateException("Global config fetch failed: HTTP ${response.code} ${response.message}")
+                            }
+                            text
+                        }
+                        if (cont.isActive) cont.resume(text)
+                    } catch (e: Exception) {
+                        if (cont.isActive) cont.resumeWithException(e)
+                    }
+                }
+            }
+            FetchResult.ok(KiloCliDataParser.parseConfig(body))
+        } catch (e: CancellationException) {
+            throw e
         } catch (e: Exception) {
             log.warn("Global config fetch failed: ${e.message}", e)
-            logResponseBody("config", e)
             FetchResult.fail("config", e)
         }
     }
@@ -644,7 +682,7 @@ class KiloBackendAppService private constructor(
         return "${warn.path}: ${warn.message}$detail"
     }
 
-    private fun configSummary(cfg: Config): String {
+    private fun configSummary(cfg: ConfigDto): String {
         val text = cfg.toString()
         return "configChars=${text.length} configHash=${text.hashCode().toUInt().toString(16)}"
     }

packages/kilo-jetbrains/backend/src/main/kotlin/ai/kilocode/backend/cli/KiloBackendCliManager.kt

@@ -304,7 +304,7 @@ internal fun buildKiloCliEnv(
     put("KILO_PLATFORM", "jetbrains")
     put("KILO_APP_NAME", "kilo-code")
     put("KILO_TELEMETRY_LEVEL", if (KiloDevMode.enabled()) "off" else "all")
-    put("KILO_DISABLE_CLAUDE_CODE", "true")
+    if (!KiloClaudeCompatSettings.get()) put("KILO_DISABLE_CLAUDE_CODE", "true")
     put("KILOCODE_FEATURE", "jetbrains-plugin")
     putIfAbsent("KILO_CONFIG_CONTENT", DEFAULT_CONFIG)
     ideEnv(log).forEach { entry -> put(entry.key, entry.value) }

packages/kilo-jetbrains/backend/src/main/kotlin/ai/kilocode/backend/cli/KiloClaudeCompatSettings.kt

@@ -0,0 +1,23 @@
+package ai.kilocode.backend.cli
+
+import com.intellij.ide.util.PropertiesComponent
+
+object KiloClaudeCompatSettings {
+    private const val KEY = "kilo.claudeCodeCompat"
+
+    @Volatile
+    private var fallback = false
+
+    fun get(): Boolean {
+        val props = props()
+        return props?.getBoolean(KEY, false) ?: fallback
+    }
+
+    fun set(value: Boolean) {
+        fallback = value
+        val props = props()
+        props?.setValue(KEY, value.toString())
+    }
+
+    private fun props(): PropertiesComponent? = runCatching { PropertiesComponent.getInstance() }.getOrNull()
+}