Remove autosave config lock from editor hot path

Drop the runtime autosave setting and config:get socket handler so backend config can be shared immutably instead of behind a mutex.

Remove autosave work from file:change, keep explicit file:save behavior, and update file/LSP handlers to read the immutable config directly.

Restore per-watch git status updates instead of the batched watcher channel because the batching path did not resolve the editor responsiveness issue.

Author: vipmax

anycode-backend/config.toml

@@ -1,6 +1,5 @@
 theme = "themes/anycode.json"
 left_panel_width = 25
-autosave = true
 
 terminal.command = "bash"
 

anycode-backend/src/app_state.rs

@@ -14,7 +14,7 @@ use tokio_util::sync::CancellationToken;
 
 #[derive(Clone)]
 pub struct AppState {
-    pub config: Arc<Mutex<Config>>,
+    pub config: Arc<Config>,
     pub file2code: Arc<Mutex<HashMap<String, Code>>>,
     pub lsp_manager: Arc<Mutex<LspManager>>,
     pub acp_manager: Arc<Mutex<AcpManager>>,

anycode-backend/src/config.rs

@@ -22,8 +22,6 @@ pub struct Config {
     pub theme: String,
     pub language: Vec<Language>,
     pub terminal: Option<Terminal>,
-    #[serde(default = "default_autosave")]
-    pub autosave: bool,
 }
 
 impl Config {
@@ -32,15 +30,10 @@ impl Config {
             theme: "default".to_string(),
             language: vec![],
             terminal: None,
-            autosave: default_autosave(),
         }
     }
 }
 
-fn default_autosave() -> bool {
-    true
-}
-
 #[derive(Debug, Deserialize, Clone)]
 pub struct Language {
     pub name: String,

anycode-backend/src/handlers/io_handler.rs

@@ -96,8 +96,7 @@ pub async fn handle_file_open(
     };
 
     let mut f2c = state.file2code.lock().await;
-    let config = state.config.lock().await;
-    let code = match get_or_create_code(&mut f2c, &abs_path, &config) {
+    let code = match get_or_create_code(&mut f2c, &abs_path, &state.config) {
         Ok(c) => c,
         Err(e) => error_ack!(ack, &abs_path, "{:?}", e),
     };
@@ -244,8 +243,7 @@ pub async fn handle_file_close(
 
     let lang = {
         let mut f2c = state.file2code.lock().await;
-        let config = state.config.lock().await;
-        let code = match get_or_create_code(&mut f2c, &abs_path, &config) {
+        let code = match get_or_create_code(&mut f2c, &abs_path, &state.config) {
             Ok(c) => c,
             Err(e) => error_ack!(ack, &abs_path, "{:?}", e),
         };
@@ -318,8 +316,7 @@ pub async fn handle_file_change(
     };
 
     let mut f2c = state.file2code.lock().await;
-    let config = state.config.lock().await;
-    let code = match get_or_create_code(&mut f2c, &abs_path, &config) {
+    let code = match get_or_create_code(&mut f2c, &abs_path, &state.config) {
         Ok(c) => c,
         Err(e) => {
             tracing::error!("Failed to get code: {:?}", e);
@@ -352,15 +349,6 @@ pub async fn handle_file_change(
         }
     }
 
-    let autosave = state.config.lock().await.autosave;
-    if autosave {
-        if let Err(e) = code.save_file() {
-            error!("Autosave failed for {}: {:?}", abs_path, e);
-        } else if let Some(lsp) = lsp_manager.get(&code.lang).await {
-            lsp.did_save(&abs_path, Some(&code.text.to_string()));
-        }
-    }
-
     // Broadcast as a single message for other clients if needed
     socket.broadcast().emit("file:change", &change).await.ok();
 }
@@ -384,8 +372,7 @@ pub async fn handle_file_save(
     };
 
     let mut f2c = state.file2code.lock().await;
-    let config = state.config.lock().await;
-    let code = match get_or_create_code(&mut f2c, &abs_path, &config) {
+    let code = match get_or_create_code(&mut f2c, &abs_path, &state.config) {
         Ok(c) => c,
         Err(e) => error_ack!(ack, &abs_path, "{:?}", e),
     };

anycode-backend/src/handlers/lsp_handler.rs

@@ -28,8 +28,7 @@ pub async fn handle_completion(
     };
 
     let mut f2c = state.file2code.lock().await;
-    let config = state.config.lock().await;
-    let code = match get_or_create_code(&mut f2c, &abs_path, &config) {
+    let code = match get_or_create_code(&mut f2c, &abs_path, &state.config) {
         Ok(c) => c,
         Err(e) => error_ack!(ack, &abs_path, "{:?}", e),
     };
@@ -69,8 +68,7 @@ pub async fn handle_hover(
     };
 
     let mut f2c = state.file2code.lock().await;
-    let config = state.config.lock().await;
-    let code = match get_or_create_code(&mut f2c, &abs_path, &config) {
+    let code = match get_or_create_code(&mut f2c, &abs_path, &state.config) {
         Ok(c) => c,
         Err(e) => error_ack!(ack, &abs_path, "{:?}", e),
     };
@@ -111,8 +109,7 @@ pub async fn handle_definition(
     };
 
     let mut f2c = state.file2code.lock().await;
-    let config = state.config.lock().await;
-    let code = match get_or_create_code(&mut f2c, &abs_path, &config) {
+    let code = match get_or_create_code(&mut f2c, &abs_path, &state.config) {
         Ok(c) => c,
         Err(e) => error_ack!(ack, &abs_path, "{:?}", e),
     };
@@ -152,8 +149,7 @@ pub async fn handle_references(
     };
 
     let mut f2c = state.file2code.lock().await;
-    let config = state.config.lock().await;
-    let code = match get_or_create_code(&mut f2c, &abs_path, &config) {
+    let code = match get_or_create_code(&mut f2c, &abs_path, &state.config) {
         Ok(c) => c,
         Err(e) => error_ack!(ack, &abs_path, "{:?}", e),
     };

anycode-backend/src/handlers/theme_handler.rs

@@ -1,7 +1,6 @@
-use crate::app_state::AppState;
 use serde::{Deserialize, Serialize};
 use serde_json::{self, json, Value};
-use socketioxide::extract::{AckSender, Data, SocketRef, State};
+use socketioxide::extract::{AckSender, Data, SocketRef};
 use std::fs;
 use std::path::PathBuf;
 use tracing::info;
@@ -160,13 +159,3 @@ pub async fn handle_theme_get(
         let _ = ack.send(&json!({ "success": false, "error": "Theme name not found in file" }));
     }
 }
-
-pub async fn handle_config_get(
-    _socket: SocketRef,
-    ack: AckSender,
-    state: State<AppState>,
-) {
-    info!("config:get requested");
-    let autosave = state.config.lock().await.autosave;
-    let _ = ack.send(&json!({ "success": true, "autosave": autosave }));
-}

anycode-backend/src/handlers/watch_handler.rs

@@ -4,13 +4,14 @@ use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
 use std::time::Duration;
-use tokio::sync::{Mutex, watch, mpsc};
+use tokio::sync::{Mutex, watch};
 use tokio_util::sync::CancellationToken;
 use tracing::info;
 
 use crate::app_state::SocketData;
 use crate::code::Code;
 use crate::diff::compute_text_edits;
+use crate::git::GitManager;
 use crate::handlers::io_handler::apply_edits_to_code;
 use crate::lsp::LspManager;
 use crate::search::search_file_result;
@@ -92,7 +93,7 @@ pub async fn handle_watch_event(
     file2code: &Arc<Mutex<HashMap<String, Code>>>,
     socket2data: &Arc<Mutex<HashMap<String, SocketData>>>,
     file_states: &Arc<Mutex<HashMap<String, FileWatchState>>>,
-    git_update_tx: &mpsc::Sender<PathBuf>,
+    git_manager: &Arc<Mutex<GitManager>>,
     lsp_manager: &Arc<Mutex<LspManager>>,
 ) {
     let normalized_path = normalize_watch_path(path);
@@ -127,7 +128,7 @@ pub async fn handle_watch_event(
     let file2code = file2code.clone();
     let socket2data = socket2data.clone();
     let file_states = file_states.clone();
-    let git_update_tx = git_update_tx.clone();
+    let git_manager = git_manager.clone();
     let lsp_manager = lsp_manager.clone();
     let path_str_key = path_str.clone();
     let event_kind = event.kind.clone();
@@ -155,7 +156,7 @@ pub async fn handle_watch_event(
         .await;
 
         handle_search_update(&path, &socket, &socket2data).await;
-        let _ = git_update_tx.send(path.clone()).await;
+        handle_changes_update(&path, &socket, &git_manager).await;
 
         let mut states = file_states.lock().await;
         if let Some(state) = states.get_mut(&path_str_key) {
@@ -271,6 +272,24 @@ async fn handle_search_update(
     }
 }
 
+async fn handle_changes_update(
+    path: &Path,
+    socket: &Arc<socketioxide::SocketIo>,
+    git_manager: &Arc<Mutex<crate::git::GitManager>>
+) {
+    let update = {
+        let mut git = git_manager.lock().await;
+        if git.should_ignore(path) {
+            return;
+        }
+        git.check_status_changed_for_paths(&[path.to_path_buf()])
+    };
+
+    if let Some(update) = update {
+        let _ = socket.emit("changes:update", &update.to_json()).await;
+    }
+}
+
 
 
 async fn handle_file_modification(

anycode-backend/src/main.rs

@@ -93,8 +93,6 @@ async fn on_connect(socket: SocketRef, _state: State<AppState>) {
 
     socket.on("theme:list", handle_theme_list);
     socket.on("theme:get", handle_theme_get);
-    socket.on("config:get", handle_config_get);
-
     socket.on_disconnect(on_disconnect)
 }
 
@@ -192,7 +190,7 @@ fn build_app_state() -> (
     let file2code = Arc::new(Mutex::new(HashMap::new()));
     let socket2data = Arc::new(Mutex::new(HashMap::new()));
     let terminals = Arc::new(Mutex::new(HashMap::new()));
-    let config = Arc::new(Mutex::new(config));
+    let config = Arc::new(config);
 
     let state = AppState {
         config,
@@ -261,7 +259,7 @@ async fn main() -> Result<()> {
     // Prepare ACP filesystem task dependencies (spawned after SocketIo creation)
     let acp_fs_file2code = state.file2code.clone();
     let acp_fs_lsp = state.lsp_manager.clone();
-    let acp_fs_config = state.config.lock().await.clone();
+    let acp_fs_config = state.config.as_ref().clone();
 
     let (layer, io) = SocketIo::builder().with_state(state.clone()).build_layer();
     let cors = ServiceBuilder::new()
@@ -303,73 +301,8 @@ async fn main() -> Result<()> {
     let dir = std::path::Path::new(".");
     watcher.watch(dir, RecursiveMode::Recursive)?;
 
-    // Create a channel for batching/debouncing git status updates
-    let (git_update_tx, mut git_update_rx) = mpsc::channel::<std::path::PathBuf>(1000);
-
-    // Spawn a task to process git status updates in a debounced, batched manner
-    let git_manager_clone = git_manager.clone();
-    let socket_clone = io.clone();
-    tokio::spawn(async move {
-        let mut paths_to_update = HashSet::new();
-
-        loop {
-            // Wait for the first path to arrive
-            let first_path = match git_update_rx.recv().await {
-                Some(path) => path,
-                None => break, // Channel closed
-            };
-            paths_to_update.insert(first_path);
-
-            // Debounce window: wait for 150ms of inactivity, or up to a max timeout (500ms) to prevent starvation
-            let start_time = std::time::Instant::now();
-            let max_wait = std::time::Duration::from_millis(500);
-
-            loop {
-                let elapsed = start_time.elapsed();
-                if elapsed >= max_wait {
-                    break;
-                }
-                let remaining = max_wait - elapsed;
-                let step_timeout = std::time::Duration::from_millis(50).min(remaining);
-
-                match tokio::time::timeout(step_timeout, git_update_rx.recv()).await {
-                    Ok(Some(path)) => {
-                        paths_to_update.insert(path);
-                    }
-                    Ok(None) => {
-                        // Channel closed
-                        break;
-                    }
-                    Err(_) => {
-                        // Timeout hit: no events for step_timeout, flush the batch
-                        break;
-                    }
-                }
-            }
-
-            // Process batched paths under a single lock on GitManager
-            if !paths_to_update.is_empty() {
-                let paths: Vec<std::path::PathBuf> = paths_to_update.drain().collect();
-                let mut git = git_manager_clone.lock().await;
-                
-                // Filter out paths that should be ignored under the lock
-                let paths_to_check: Vec<std::path::PathBuf> = paths
-                    .into_iter()
-                    .filter(|path| !git.should_ignore(path))
-                    .collect();
-
-                if !paths_to_check.is_empty() {
-                    if let Some(update) = git.check_status_changed_for_paths(&paths_to_check) {
-                        let _ = socket_clone.emit("changes:update", &update.to_json()).await;
-                    }
-                }
-            }
-        }
-    });
-
     let file_states = Arc::new(Mutex::new(HashMap::new()));
     let socket = io.clone();
-    let git_update_tx_clone = git_update_tx.clone();
     tokio::spawn(async move {
         while let Some(res) = watch_rx.recv().await {
             match res {
@@ -385,7 +318,7 @@ async fn main() -> Result<()> {
                                 &file2code,
                                 &socket2data,
                                 &file_states,
-                                &git_update_tx_clone,
+                                &git_manager,
                                 &lsp_manager,
                             )
                             .await

anycode/hooks/useSettings.ts

@@ -1,24 +1,3 @@
-import { useEffect } from 'react';
-import type { Socket } from 'socket.io-client';
-
-type UseSettingsParams = {
-    wsRef: React.RefObject<Socket | null>;
-    isConnected: boolean;
-};
-
-export const useSettings = ({ wsRef, isConnected }: UseSettingsParams) => {
-    useEffect(() => {
-        if (!isConnected || !wsRef.current) {
-            return;
-        }
-
-        wsRef.current.emit('config:get', (res: any) => {
-            if (res && res.success) {
-                // Config loaded
-            }
-        });
-    }, [isConnected, wsRef]);
-
+export const useSettings = () => {
     return {};
 };
-