feat(servers): write-only space config save with async file-watcher sync

Decouple Custom Server Configuration saves from the install pipeline.
save_space_config now validates and writes the JSON file only; the
existing space file watcher picks up the change and runs
UserSpaceSyncService::sync_from_file asynchronously, emitting
space-servers-updated/space-servers-sync-failed events instead of
blocking the save on install-time errors.

- space.rs: drop sync_from_file call from save_space_config
- file_watcher.rs: derive space_id from filename, emit success/failure
  callbacks with unit tests
- lib.rs: wire space-servers-updated / space-servers-sync-failed
  Tauri events from the watcher callbacks
- useDomainEvents.ts: register both channels through the existing
  Tauri/web dispatcher instead of a page-level isTauri() branch
- ServersPage.tsx: subscribe via useDomainEvents; warning toast on
  sync failure
- ConfigEditorModal.tsx: drop refreshRegistry() from handleSave

Also adds docs/planning/istauri-audit.md (isTauri() usage audit) and
docs/planning/user-config-sync-collision-fix.md (follow-up plan for
the cross-source ID collision bug this surfaced).

Signed-off-by: crimsonsunset <jsangio1@gmail.com>

Author: crimsonsunset

.gitignore

@@ -93,3 +93,6 @@ apps/desktop/src-tauri/target/release/bundle/
 debug/
 *.dSYM/
 
+
+# Cursor rules — symlinked from ~/.cursor/rules/projects/
+.cursor/rules/

apps/desktop/src-tauri/src/commands/space.rs

@@ -6,10 +6,7 @@
 //! built-in fallback. The desktop UI tracks which space the user is
 //! viewing in its own Zustand store (frontend-only state).
 
-use mcpmux_core::{
-    application::UserSpaceSyncService, validate_workspace_root, Space, SpaceBaseDir,
-    WorkspaceRootValidation,
-};
+use mcpmux_core::{validate_workspace_root, Space, SpaceBaseDir, WorkspaceRootValidation};
 use std::sync::Arc;
 use tauri::{AppHandle, State};
 use tokio::sync::RwLock;
@@ -238,24 +235,6 @@ pub async fn save_space_config(
     std::fs::write(&config_path, content)
         .map_err(|e| format!("Failed to write config file: {}", e))?;
 
-    // Do not rely solely on the debounced file watcher. The UI reloads immediately
-    // after this command returns, so sync the just-saved file into InstalledServer
-    // records synchronously to avoid stale/missing custom-server state.
-    let sync_service = UserSpaceSyncService::new(state.installed_server_repository.clone());
-    let sync_result = sync_service
-        .sync_from_file(&space_id, &config_path)
-        .await
-        .map_err(|e| format!("Failed to sync custom server config: {}", e))?;
-
-    if sync_result.has_changes() {
-        info!(
-            "[save_space_config] Synced custom server config: {} added, {} updated, {} removed",
-            sync_result.added.len(),
-            sync_result.updated.len(),
-            sync_result.removed.len()
-        );
-    }
-
     Ok(())
 }
 

apps/desktop/src-tauri/src/lib.rs

@@ -643,25 +643,49 @@ pub fn run() {
                 let default_space_id = "00000000-0000-0000-0000-000000000001".to_string();
 
                 tauri::async_runtime::spawn(async move {
+                    let app_handle_success = app_handle_for_watcher.clone();
+                    let app_handle_error = app_handle_for_watcher;
 
                     // Create file watcher with UI event emitter
                     match services::SpaceFileWatcher::new(
                         spaces_dir.clone(),
                         Arc::new(mcpmux_core::application::UserSpaceSyncService::new(installed_repo)),
                         default_space_id,
-                        Some(move |space_id: &str, result: &mcpmux_core::application::SyncResult| {
-                            // Emit event to refresh UI
-                            if result.has_changes() {
-                                if let Err(e) = app_handle_for_watcher.emit("space-servers-updated", serde_json::json!({
-                                    "space_id": space_id,
-                                    "added": result.added,
-                                    "updated": result.updated,
-                                    "removed": result.removed,
-                                })) {
-                                    warn!("[FileWatcher] Failed to emit event: {}", e);
-                                }
-                            }
-                        }),
+                        services::SpaceFileWatcherEmitters {
+                            on_success: Some(Arc::new(
+                                move |space_id: &str, result: &mcpmux_core::application::SyncResult| {
+                                    if result.has_changes() {
+                                        if let Err(e) = app_handle_success.emit(
+                                            "space-servers-updated",
+                                            serde_json::json!({
+                                                "space_id": space_id,
+                                                "added": result.added,
+                                                "updated": result.updated,
+                                                "removed": result.removed,
+                                            }),
+                                        ) {
+                                            warn!("[FileWatcher] Failed to emit event: {}", e);
+                                        }
+                                    }
+                                },
+                            )),
+                            on_error: Some(Arc::new(
+                                move |space_id: &str, message: &str| {
+                                    if let Err(e) = app_handle_error.emit(
+                                        "space-servers-sync-failed",
+                                        serde_json::json!({
+                                            "space_id": space_id,
+                                            "message": message,
+                                        }),
+                                    ) {
+                                        warn!(
+                                            "[FileWatcher] Failed to emit sync failure: {}",
+                                            e
+                                        );
+                                    }
+                                },
+                            )),
+                        },
                     ) {
                         Ok(_watcher) => {
                             info!("[FileWatcher] Started watching: {:?}", spaces_dir);

apps/desktop/src-tauri/src/services/file_watcher.rs

@@ -12,10 +12,20 @@ use anyhow::Result;
 use notify::{Event, EventKind, RecommendedWatcher, RecursiveMode, Watcher};
 use tokio::sync::mpsc;
 use tracing::{debug, error, info, warn};
+use uuid::Uuid;
 
 use mcpmux_core::application::{SyncResult, UserSpaceSyncService};
 use mcpmux_core::InstalledServerRepository;
 
+type SyncSuccessHandler = Arc<dyn Fn(&str, &SyncResult) + Send + Sync>;
+type SyncErrorHandler = Arc<dyn Fn(&str, &str) + Send + Sync>;
+
+/// Optional UI callbacks for background config sync.
+pub struct SpaceFileWatcherEmitters {
+    pub on_success: Option<SyncSuccessHandler>,
+    pub on_error: Option<SyncErrorHandler>,
+}
+
 /// File watcher for user space configuration files
 ///
 /// Monitors a directory for JSON file changes and syncs servers
@@ -34,17 +44,14 @@ impl SpaceFileWatcher {
     /// # Arguments
     /// * `spaces_dir` - Directory containing space JSON config files
     /// * `sync_service` - Service to sync changes
-    /// * `default_space_id` - Default space ID to use for synced servers
-    /// * `event_emitter` - Optional callback to emit UI events after sync
-    pub fn new<F>(
+    /// * `default_space_id` - Fallback space ID when filename stem is not a UUID
+    /// * `emitters` - Optional callbacks for sync success/failure
+    pub fn new(
         spaces_dir: PathBuf,
         sync_service: Arc<UserSpaceSyncService>,
         default_space_id: String,
-        event_emitter: Option<F>,
-    ) -> Result<Self>
-    where
-        F: Fn(&str, &SyncResult) + Send + Sync + 'static,
-    {
+        emitters: SpaceFileWatcherEmitters,
+    ) -> Result<Self> {
         // Ensure directory exists
         if !spaces_dir.exists() {
             std::fs::create_dir_all(&spaces_dir)?;
@@ -56,10 +63,9 @@ impl SpaceFileWatcher {
         // Spawn debounced handler
         let sync_clone = sync_service.clone();
         let space_id = default_space_id.clone();
-        let emitter = event_emitter.map(Arc::new);
 
         tokio::spawn(async move {
-            Self::debounced_handler(rx, sync_clone, space_id, emitter).await;
+            Self::debounced_handler(rx, sync_clone, space_id, emitters).await;
         });
 
         // Create file watcher
@@ -97,17 +103,24 @@ impl SpaceFileWatcher {
         })
     }
 
+    /// Resolve space ID from a config filename stem when it is a UUID.
+    fn space_id_from_config_path(path: &Path, default_space_id: &str) -> String {
+        path.file_stem()
+            .and_then(|stem| stem.to_str())
+            .filter(|stem| Uuid::parse_str(stem).is_ok())
+            .map(String::from)
+            .unwrap_or_else(|| default_space_id.to_string())
+    }
+
     /// Debounced handler for file changes
     ///
     /// Groups rapid file changes and syncs after a debounce period.
-    async fn debounced_handler<F>(
+    async fn debounced_handler(
         mut rx: mpsc::Receiver<PathBuf>,
         sync_service: Arc<UserSpaceSyncService>,
         default_space_id: String,
-        event_emitter: Option<Arc<F>>,
-    ) where
-        F: Fn(&str, &SyncResult) + Send + Sync + 'static,
-    {
+        emitters: SpaceFileWatcherEmitters,
+    ) {
         let debounce_duration = Duration::from_millis(500);
         let mut pending: HashMap<PathBuf, Instant> = HashMap::new();
 
@@ -129,13 +142,12 @@ impl SpaceFileWatcher {
                     for path in ready {
                         pending.remove(&path);
 
-                        // Extract space_id from filename (e.g., "default.json" -> use default_space_id)
-                        // For now, use the default space for all config files
-                        let space_id = &default_space_id;
+                        let space_id =
+                            Self::space_id_from_config_path(&path, &default_space_id);
 
                         info!("Syncing changes from: {:?}", path);
 
-                        match sync_service.sync_from_file(space_id, &path).await {
+                        match sync_service.sync_from_file(&space_id, &path).await {
                             Ok(result) => {
                                 if result.has_changes() {
                                     info!(
@@ -145,16 +157,19 @@ impl SpaceFileWatcher {
                                         result.removed.len()
                                     );
 
-                                    // Emit event for UI refresh
-                                    if let Some(ref emitter) = event_emitter {
-                                        emitter(space_id, &result);
+                                    if let Some(ref emitter) = emitters.on_success {
+                                        emitter(&space_id, &result);
                                     }
                                 } else {
                                     debug!("Sync complete: no changes");
                                 }
                             }
                             Err(e) => {
-                                error!("Sync failed for {:?}: {}", path, e);
+                                let message = e.to_string();
+                                error!("Sync failed for {:?}: {}", path, message);
+                                if let Some(ref emitter) = emitters.on_error {
+                                    emitter(&space_id, &message);
+                                }
                             }
                         }
                     }
@@ -198,11 +213,14 @@ impl SpaceFileWatcherBuilder {
     /// Build the file watcher without event emitter
     pub fn build(self) -> Result<SpaceFileWatcher> {
         let sync_service = Arc::new(UserSpaceSyncService::new(self.installed_repo));
-        SpaceFileWatcher::new::<fn(&str, &SyncResult)>(
+        SpaceFileWatcher::new(
             self.spaces_dir,
             sync_service,
             self.default_space_id,
-            None,
+            SpaceFileWatcherEmitters {
+                on_success: None,
+                on_error: None,
+            },
         )
     }
 
@@ -216,17 +234,34 @@ impl SpaceFileWatcherBuilder {
             self.spaces_dir,
             sync_service,
             self.default_space_id,
-            Some(emitter),
+            SpaceFileWatcherEmitters {
+                on_success: Some(Arc::new(emitter)),
+                on_error: None,
+            },
         )
     }
 }
 
 #[cfg(test)]
 mod tests {
+    use super::*;
+    use std::path::Path;
+
+    #[test]
+    fn space_id_from_config_path_uses_uuid_stem() {
+        let path = Path::new("/tmp/spaces/00000000-0000-0000-0000-000000000001.json");
+        assert_eq!(
+            SpaceFileWatcher::space_id_from_config_path(path, "fallback"),
+            "00000000-0000-0000-0000-000000000001"
+        );
+    }
 
     #[test]
-    fn test_builder_default_space_id() {
-        // Just test the builder pattern compiles
-        // Actual functionality tested via integration tests
+    fn space_id_from_config_path_falls_back_for_non_uuid_stem() {
+        let path = Path::new("/tmp/spaces/default.json");
+        assert_eq!(
+            SpaceFileWatcher::space_id_from_config_path(path, "fallback-id"),
+            "fallback-id"
+        );
     }
 }

apps/desktop/src-tauri/src/services/mod.rs

@@ -8,4 +8,4 @@ pub mod file_watcher;
 pub mod ui_events;
 
 pub use admin_server::AdminServerState;
-pub use file_watcher::SpaceFileWatcher;
+pub use file_watcher::{SpaceFileWatcher, SpaceFileWatcherEmitters};

apps/desktop/src/components/ConfigEditorModal.tsx

@@ -2,7 +2,6 @@ import { useState, useEffect, useCallback, useRef } from 'react';
 import { useTranslation } from 'react-i18next';
 import { X, Save, Loader2, AlertTriangle, Wand2, Plus } from 'lucide-react';
 import { readSpaceConfig, saveSpaceConfig } from '@/lib/api/spaces';
-import { refreshRegistry } from '@/lib/api/registry';
 import { type Monaco } from '@monaco-editor/react';
 import type { editor } from 'monaco-editor';
 import { useToast, ToastContainer } from '@mcpmux/ui';
@@ -143,8 +142,6 @@ export function ConfigEditorModal({
       setIsSaving(true);
       setError(null);
       await saveSpaceConfig(spaceId, content);
-      // Refresh server discovery to pick up new/changed servers
-      await refreshRegistry();
 
       success(t('configEditorModal.toast.saved'), t('configEditorModal.toast.savedBody'));
       onSaved();

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

@@ -278,7 +278,7 @@ export function ServersPage() {
   const [actionLoading, setActionLoading] = useState<string | null>(null);
   const gatewayControl = useGatewayControl();
   // Bottom toast notifications
-  const [toast, setToast] = useState<{ message: string; type: 'success' | 'error' | 'info' } | null>(null);
+  const [toast, setToast] = useState<{ message: string; type: 'success' | 'error' | 'info' | 'warning' } | null>(null);
   const [configModal, setConfigModal] = useState<ConfigModalState>({
     open: false,
     server: null,
@@ -371,7 +371,7 @@ export function ServersPage() {
   }, [authProgress]);
 
   // Show toast notification
-  const showToast = useCallback((message: string, type: 'success' | 'error' | 'info' = 'info') => {
+  const showToast = useCallback((message: string, type: 'success' | 'error' | 'info' | 'warning' = 'info') => {
     setToast({ message, type });
     setTimeout(() => setToast(null), 5000);
   }, []);
@@ -513,6 +513,27 @@ export function ServersPage() {
     });
   }, [loadData, subscribe, viewSpace]);
 
+  useEffect(() => {
+    return subscribe('space-servers-updated', (payload) => {
+      if (viewSpace && payload.space_id !== viewSpace.id) {
+        return;
+      }
+      void loadData();
+    });
+  }, [loadData, subscribe, viewSpace]);
+
+  useEffect(() => {
+    return subscribe('space-servers-sync-failed', (payload) => {
+      if (viewSpace && payload.space_id !== viewSpace.id) {
+        return;
+      }
+      showToast(
+        `${t('configEditorModal.toast.syncFailedTitle')}: ${t('configEditorModal.toast.syncFailedBody', { message: payload.message })}`,
+        'warning',
+      );
+    });
+  }, [showToast, subscribe, t, viewSpace]);
+
   useEffect(() => {
     return subscribe('server-update-available', (payload: ServerUpdateAvailablePayload) => {
       if (!viewSpace || payload.space_id !== viewSpace.id) {
@@ -2590,10 +2611,13 @@ export function ServersPage() {
               ? 'bg-[rgb(var(--success))]/90 border-[rgb(var(--success))] text-white'
               : toast.type === 'error'
               ? 'bg-[rgb(var(--error))]/90 border-[rgb(var(--error))] text-white'
+              : toast.type === 'warning'
+              ? 'bg-amber-500/90 border-amber-500 text-white'
               : 'bg-[rgb(var(--primary))]/90 border-[rgb(var(--primary))] text-white'
           }`}>
             {toast.type === 'success' && <span className="text-lg">✓</span>}
             {toast.type === 'error' && <span className="text-lg">✕</span>}
+            {toast.type === 'warning' && <span className="text-lg">!</span>}
             {toast.type === 'info' && <span className="text-lg">ℹ</span>}
             <span className="text-sm font-medium">{toast.message}</span>
             <button