fix: always send custom fields on save and add corner case tests

Fix a bug where removing all env vars/args/headers in the config
modal would send undefined to the backend, which treats None as
"keep existing" — so the fields were never actually cleared. Now
always sends the values (even if empty) so clearing works correctly.

Add corner case tests:
- Rust unit: empty keys, key overwrite, special characters (unicode,
  quotes, equals in keys, newlines), clearing fields to empty,
  large args lists (100 items)
- Rust integration: clearing custom fields via DB update, special
  characters round-trip through SQLite

https://claude.ai/code/session_01V5tgbLyeWrPW5zZ1toRoPZ

Author: claude

apps/desktop/src/features/servers/ServersPage.tsx

@@ -587,14 +587,17 @@ export function ServersPage() {
     try {
       const { saveServerInputs } = await import('@/lib/api/registry');
 
-      // Save input values with env overrides, args, and headers
+      // Save input values with env overrides, args, and headers.
+      // Always send the values (even if empty) so that clearing them works.
+      // Backend treats None as "keep existing", so we must send Some({}/[])
+      // to actually clear fields the user removed.
       await saveServerInputs(
         serverId,
         configModal.inputValues,
         viewSpace?.id ?? '',
-        Object.keys(configModal.envOverrides).length > 0 ? configModal.envOverrides : undefined,
-        configModal.argsAppend.length > 0 ? configModal.argsAppend : undefined,
-        Object.keys(configModal.extraHeaders).length > 0 ? configModal.extraHeaders : undefined,
+        configModal.envOverrides,
+        configModal.argsAppend,
+        configModal.extraHeaders,
       );
 
       setConfigModal({ open: false, server: null, inputValues: {}, envOverrides: {}, argsAppend: [], extraHeaders: {} });

crates/mcpmux-core/src/domain/installed_server.rs

@@ -338,4 +338,116 @@ mod tests {
         assert!(server.args_append.is_empty());
         assert!(server.extra_headers.is_empty());
     }
+
+    #[test]
+    fn test_env_overrides_empty_key_allowed() {
+        let mut server = InstalledServer::new("space_default", "test-server");
+        server
+            .env_overrides
+            .insert("".to_string(), "value".to_string());
+
+        assert_eq!(server.env_overrides.get(""), Some(&"value".to_string()));
+
+        // Serialize and deserialize
+        let json = serde_json::to_string(&server).expect("serialize");
+        let deserialized: InstalledServer = serde_json::from_str(&json).expect("deserialize");
+        assert_eq!(deserialized.env_overrides.get(""), Some(&"value".to_string()));
+    }
+
+    #[test]
+    fn test_env_overrides_overwrite_existing_key() {
+        let mut server = InstalledServer::new("space_default", "test-server");
+        server
+            .env_overrides
+            .insert("KEY".to_string(), "first".to_string());
+        server
+            .env_overrides
+            .insert("KEY".to_string(), "second".to_string());
+
+        assert_eq!(server.env_overrides.len(), 1);
+        assert_eq!(
+            server.env_overrides.get("KEY"),
+            Some(&"second".to_string())
+        );
+    }
+
+    #[test]
+    fn test_special_characters_in_values() {
+        let mut server = InstalledServer::new("space_default", "test-server");
+        // Env var with special chars
+        server.env_overrides.insert(
+            "PATH_WITH=EQUALS".to_string(),
+            "value with spaces & \"quotes\" and \nnewlines".to_string(),
+        );
+        // Args with special chars
+        server.args_append = vec![
+            "--config=/path/to/file".to_string(),
+            "arg with spaces".to_string(),
+            "unicode: 日本語".to_string(),
+        ];
+        // Header with special chars
+        server.extra_headers.insert(
+            "X-Special".to_string(),
+            "value/with:colons and;semicolons".to_string(),
+        );
+
+        let json = serde_json::to_string(&server).expect("serialize");
+        let deserialized: InstalledServer = serde_json::from_str(&json).expect("deserialize");
+
+        assert_eq!(
+            deserialized.env_overrides.get("PATH_WITH=EQUALS"),
+            Some(&"value with spaces & \"quotes\" and \nnewlines".to_string())
+        );
+        assert_eq!(deserialized.args_append[2], "unicode: 日本語");
+        assert_eq!(
+            deserialized.extra_headers.get("X-Special"),
+            Some(&"value/with:colons and;semicolons".to_string())
+        );
+    }
+
+    #[test]
+    fn test_clear_custom_fields_to_empty() {
+        let mut server = InstalledServer::new("space_default", "test-server");
+        // Set values
+        server
+            .env_overrides
+            .insert("KEY".to_string(), "value".to_string());
+        server.args_append = vec!["--flag".to_string()];
+        server
+            .extra_headers
+            .insert("X-Test".to_string(), "test".to_string());
+
+        assert!(!server.env_overrides.is_empty());
+        assert!(!server.args_append.is_empty());
+        assert!(!server.extra_headers.is_empty());
+
+        // Clear all fields
+        server.env_overrides = HashMap::new();
+        server.args_append = Vec::new();
+        server.extra_headers = HashMap::new();
+
+        assert!(server.env_overrides.is_empty());
+        assert!(server.args_append.is_empty());
+        assert!(server.extra_headers.is_empty());
+
+        // Verify empty fields serialize/deserialize correctly
+        let json = serde_json::to_string(&server).expect("serialize");
+        let deserialized: InstalledServer = serde_json::from_str(&json).expect("deserialize");
+        assert!(deserialized.env_overrides.is_empty());
+        assert!(deserialized.args_append.is_empty());
+        assert!(deserialized.extra_headers.is_empty());
+    }
+
+    #[test]
+    fn test_large_args_list() {
+        let mut server = InstalledServer::new("space_default", "test-server");
+        server.args_append = (0..100).map(|i| format!("--arg-{}", i)).collect();
+
+        assert_eq!(server.args_append.len(), 100);
+
+        let json = serde_json::to_string(&server).expect("serialize");
+        let deserialized: InstalledServer = serde_json::from_str(&json).expect("deserialize");
+        assert_eq!(deserialized.args_append.len(), 100);
+        assert_eq!(deserialized.args_append[99], "--arg-99");
+    }
 }

tests/rust/tests/database/installed_server.rs

@@ -605,3 +605,112 @@ async fn test_installed_server_empty_custom_fields_by_default() {
     assert!(loaded.args_append.is_empty());
     assert!(loaded.extra_headers.is_empty());
 }
+
+#[tokio::test]
+async fn test_installed_server_clear_custom_fields_via_update() {
+    let test_db = TestDatabase::new();
+    let db = Arc::new(Mutex::new(test_db.db));
+    let server_repo = SqliteInstalledServerRepository::new(Arc::clone(&db));
+    let space_repo = SqliteSpaceRepository::new(db);
+
+    let space = fixtures::test_space("Test Space");
+    SpaceRepository::create(&space_repo, &space).await.unwrap();
+
+    // Install server WITH custom fields
+    let mut server = fixtures::test_installed_server(&space.id.to_string(), "clearable-server");
+    server
+        .env_overrides
+        .insert("KEY".to_string(), "value".to_string());
+    server.args_append = vec!["--flag".to_string()];
+    server
+        .extra_headers
+        .insert("X-Test".to_string(), "test".to_string());
+
+    let server_id = server.id;
+    InstalledServerRepository::install(&server_repo, &server)
+        .await
+        .unwrap();
+
+    // Verify they're set
+    let loaded = InstalledServerRepository::get(&server_repo, &server_id)
+        .await
+        .unwrap()
+        .unwrap();
+    assert_eq!(loaded.env_overrides.len(), 1);
+    assert_eq!(loaded.args_append.len(), 1);
+    assert_eq!(loaded.extra_headers.len(), 1);
+
+    // Clear all fields by updating with empty collections
+    let mut to_update = loaded;
+    to_update.env_overrides = HashMap::new();
+    to_update.args_append = Vec::new();
+    to_update.extra_headers = HashMap::new();
+
+    InstalledServerRepository::update(&server_repo, &to_update)
+        .await
+        .expect("Failed to update server");
+
+    // Verify they're cleared
+    let cleared = InstalledServerRepository::get(&server_repo, &server_id)
+        .await
+        .unwrap()
+        .unwrap();
+    assert!(
+        cleared.env_overrides.is_empty(),
+        "env_overrides should be empty after clearing"
+    );
+    assert!(
+        cleared.args_append.is_empty(),
+        "args_append should be empty after clearing"
+    );
+    assert!(
+        cleared.extra_headers.is_empty(),
+        "extra_headers should be empty after clearing"
+    );
+}
+
+#[tokio::test]
+async fn test_installed_server_special_characters_persist() {
+    let test_db = TestDatabase::new();
+    let db = Arc::new(Mutex::new(test_db.db));
+    let server_repo = SqliteInstalledServerRepository::new(Arc::clone(&db));
+    let space_repo = SqliteSpaceRepository::new(db);
+
+    let space = fixtures::test_space("Test Space");
+    SpaceRepository::create(&space_repo, &space).await.unwrap();
+
+    let mut server = fixtures::test_installed_server(&space.id.to_string(), "special-server");
+    // Values with special characters
+    server.env_overrides.insert(
+        "PATH_WITH=EQUALS".to_string(),
+        "value with \"quotes\" and 'apostrophes'".to_string(),
+    );
+    server.args_append = vec![
+        "--config=/path/to/file with spaces".to_string(),
+        "unicode: 日本語".to_string(),
+    ];
+    server
+        .extra_headers
+        .insert("Authorization".to_string(), "Bearer tok3n+/=".to_string());
+
+    let server_id = server.id;
+    InstalledServerRepository::install(&server_repo, &server)
+        .await
+        .unwrap();
+
+    let loaded = InstalledServerRepository::get(&server_repo, &server_id)
+        .await
+        .unwrap()
+        .unwrap();
+
+    assert_eq!(
+        loaded.env_overrides.get("PATH_WITH=EQUALS"),
+        Some(&"value with \"quotes\" and 'apostrophes'".to_string())
+    );
+    assert_eq!(loaded.args_append[0], "--config=/path/to/file with spaces");
+    assert_eq!(loaded.args_append[1], "unicode: 日本語");
+    assert_eq!(
+        loaded.extra_headers.get("Authorization"),
+        Some(&"Bearer tok3n+/=".to_string())
+    );
+}