Fix backend autosave and LSP notification errors

vipmax · vipmax · commit 5162334a748c · 2026-05-23T14:05:22.000+03:00
diff --git a/anycode-backend/src/acp_fs.rs b/anycode-backend/src/acp_fs.rs
@@ -121,8 +121,6 @@ async fn handle_write(
         }
 
         let lang = code.lang.clone();
-        let saved_content = code.get_content();
-
         // Serialize edits for frontend notification
         let edits_json = json!({
             "file": abs_path,
@@ -141,8 +139,12 @@ async fn handle_write(
         if !lsp_changes.is_empty() {
             let mut lsp = lsp_manager.lock().await;
             if let Some(lsp) = lsp.get(&lang).await {
-                lsp.did_change_multi(&abs_path, lsp_changes).await;
-                lsp.did_save(&abs_path, Some(&saved_content));
+                if let Err(e) = lsp.did_change_multi(&abs_path, lsp_changes).await {
+                    error!("ACP write: failed to notify LSP didChange for {}: {}", abs_path, e);
+                }
+                if let Err(e) = lsp.did_save(&abs_path) {
+                    error!("ACP write: failed to notify LSP didSave for {}: {}", abs_path, e);
+                }
             }
         }
 
diff --git a/anycode-backend/src/handlers/io_handler.rs b/anycode-backend/src/handlers/io_handler.rs
@@ -142,7 +142,9 @@ pub async fn handle_file_open(
 
     let mut lsp_manager = state.lsp_manager.lock().await;
     if let Some(lsp) = lsp_manager.get(&code.lang).await {
-        lsp.did_open(&code.lang, &abs_path, &content);
+        if let Err(e) = lsp.did_open(&code.lang, &abs_path, &content) {
+            error!("Failed to notify LSP didOpen for {}: {:?}", abs_path, e);
+        }
     }
 }
 
@@ -254,7 +256,9 @@ pub async fn handle_file_close(
     {
         let mut lsp_manager = state.lsp_manager.lock().await;
         if let Some(lsp) = lsp_manager.get(&lang).await {
-            lsp.did_close(&abs_path);
+            if let Err(e) = lsp.did_close(&abs_path) {
+                error!("Failed to notify LSP didClose for {}: {:?}", abs_path, e);
+            }
         }
     }
 
@@ -315,37 +319,58 @@ pub async fn handle_file_change(
         }
     };
 
-    let mut f2c = state.file2code.lock().await;
-    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);
-            return;
-        }
-    };
-
-    let mut lsp_manager = state.lsp_manager.lock().await;
     let edits = change.edits.clone();
+    let (lsp_changes, lang, did_autosave) = {
+        let mut f2c = state.file2code.lock().await;
+        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);
+                return;
+            }
+        };
 
-    let mut apply_tx = true;
+        let mut apply_tx = true;
 
-    if let Some(true) = change.is_undo {
-        let _undo = code.undo_change();
-        apply_tx = false;
-    }
+        if let Some(true) = change.is_undo {
+            let _undo = code.undo_change();
+            apply_tx = false;
+        }
 
-    if let Some(true) = change.is_redo {
-        let _redo = code.redo_change();
-        apply_tx = false;
-    }
+        if let Some(true) = change.is_redo {
+            let _redo = code.redo_change();
+            apply_tx = false;
+        }
 
-    // Apply all edits to code and collect LSP changes
-    let lsp_changes = apply_edits_to_code(code, &edits, apply_tx);
+        // Apply all edits to code and collect LSP changes
+        let lsp_changes = apply_edits_to_code(code, &edits, apply_tx);
+        let lang = code.lang.clone();
+        let did_autosave = match code.save_file() {
+            Ok(()) => true,
+            Err(e) => {
+                error!("Autosave failed for {}: {:?}", abs_path, e);
+                false
+            }
+        };
+
+        (lsp_changes, lang, did_autosave)
+    };
 
-    // Send all changes to LSP in a single notification
-    if !lsp_changes.is_empty() {
-        if let Some(lsp) = lsp_manager.get(&code.lang).await {
-            lsp.did_change_multi(&abs_path, lsp_changes).await;
+    // Send all changes to LSP in a single notification, then notify save after autosave.
+    if !lsp_changes.is_empty() || did_autosave {
+        let mut lsp_manager = state.lsp_manager.lock().await;
+        if let Some(lsp) = lsp_manager.get(&lang).await {
+            if !lsp_changes.is_empty() {
+                if let Err(e) = lsp.did_change_multi(&abs_path, lsp_changes).await {
+                    error!("Failed to notify LSP didChange for {}: {:?}", abs_path, e);
+                }
+            }
+
+            if did_autosave {
+                if let Err(e) = lsp.did_save(&abs_path) {
+                    error!("Failed to notify LSP didSave for {}: {:?}", abs_path, e);
+                }
+            }
         }
     }
 
@@ -385,7 +410,9 @@ pub async fn handle_file_save(
 
     let mut lsp_manager = state.lsp_manager.lock().await;
     if let Some(lsp) = lsp_manager.get(&code.lang).await {
-        lsp.did_save(&abs_path, Some(&code.text.to_string()));
+        if let Err(e) = lsp.did_save(&abs_path) {
+            error!("Failed to notify LSP didSave for {}: {:?}", abs_path, e);
+        }
     }
 
     ack.send(&json!({ "success": true, "file": abs_path })).ok();
diff --git a/anycode-backend/src/handlers/watch_handler.rs b/anycode-backend/src/handlers/watch_handler.rs
@@ -6,7 +6,7 @@ use std::sync::Arc;
 use std::time::Duration;
 use tokio::sync::{Mutex, watch};
 use tokio_util::sync::CancellationToken;
-use tracing::info;
+use tracing::{error, info};
 
 use crate::app_state::SocketData;
 use crate::code::Code;
@@ -353,8 +353,12 @@ async fn handle_file_modification(
     if !lsp_changes.is_empty() {
         let mut lsp = lsp_manager.lock().await;
         if let Some(lsp) = lsp.get(&lang).await {
-            lsp.did_change_multi(path_str, lsp_changes).await;
-            lsp.did_save(path_str, Some(&new_text));
+            if let Err(e) = lsp.did_change_multi(path_str, lsp_changes).await {
+                error!("Failed to notify LSP didChange for {}: {:?}", path_str, e);
+            }
+            if let Err(e) = lsp.did_save(path_str) {
+                error!("Failed to notify LSP didSave for {}: {:?}", path_str, e);
+            }
         }
     }
 
diff --git a/anycode-backend/src/lsp.rs b/anycode-backend/src/lsp.rs
@@ -1,3 +1,4 @@
+use anyhow::Result;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use std::collections::{HashMap, HashSet};
@@ -215,11 +216,11 @@ impl Lsp {
         }
     }
 
-    pub async fn init(&mut self, dir: &str) {
+    pub async fn init(&mut self, dir: &str) -> Result<()> {
         let id = 0;
         let (tx, rx) = mpsc::channel::<String>(1);
         self.add_pending(id, tx).await;
-        let message = lsp_messages::initialize(dir, self.lsp_name.as_deref());
+        let message = lsp_messages::initialize(dir, self.lsp_name.as_deref())?;
         self.send_async(message);
         self.wait(5, rx).await;
         self.remove_pending(id).await;
@@ -231,7 +232,8 @@ impl Lsp {
             self.did_change_configuration(settings);
         }
 
-        self.ready.store(true, Ordering::SeqCst)
+        self.ready.store(true, Ordering::SeqCst);
+        Ok(())
     }
 
     pub fn send_notification<N>(&self, params: N::Params)
@@ -308,41 +310,41 @@ impl Lsp {
         self.send_notification::<DidChangeConfiguration>(params);
     }
 
-    pub fn did_open(&mut self, lang: &str, path: &str, text: &str) {
+    pub fn did_open(&mut self, lang: &str, path: &str, text: &str) -> Result<()> {
         self.opened.insert(path.to_string());
-
+        let uri = path_to_uri(path)?;
         let params = DidOpenTextDocumentParams {
             text_document: TextDocumentItem {
-                uri: path_to_uri(path).unwrap(),
+                uri,
                 language_id: lang.to_string(),
                 version: 0,
                 text: text.to_string(),
             },
         };
         self.send_notification::<DidOpenTextDocument>(params);
+        Ok(())
     }
 
-    pub fn did_close(&mut self, path: &str) {
+    pub fn did_close(&mut self, path: &str) -> Result<()> {
         if !self.opened.remove(path) {
-            return;
+            return Ok(());
         }
+        let uri = path_to_uri(path)?;
         let params = DidCloseTextDocumentParams {
-            text_document: TextDocumentIdentifier {
-                uri: path_to_uri(path).unwrap(),
-            },
+            text_document: TextDocumentIdentifier { uri },
         };
         self.send_notification::<DidCloseTextDocument>(params);
+        Ok(())
     }
 
-    pub fn did_save(&mut self, path: &str, text: Option<&str>) {
+    pub fn did_save(&mut self, path: &str) -> Result<()> {
+        let uri = path_to_uri(path)?;
         let params = DidSaveTextDocumentParams {
-            text_document: TextDocumentIdentifier {
-                uri: path_to_uri(path).unwrap(),
-            },
+            text_document: TextDocumentIdentifier { uri },
             text: None,
-            // text: text.map(|s| s.to_string()),
         };
         self.send_notification::<DidSaveTextDocument>(params);
+        Ok(())
     }
 
     fn get_next_version(&mut self, path: &str) -> usize {
@@ -366,7 +368,7 @@ impl Lsp {
         end_column: usize,
         path: &str,
         text: &str,
-    ) {
+    ) -> Result<()> {
         self.did_change_multi(
             path,
             vec![TextDocumentContentChangeEvent {
@@ -378,23 +380,25 @@ impl Lsp {
                 text: text.to_string(),
             }],
         )
-        .await;
+        .await
     }
 
     pub async fn did_change_multi(
         &mut self,
         path: &str,
         content_changes: Vec<TextDocumentContentChangeEvent>,
-    ) {
+    ) -> Result<()> {
+        let uri = path_to_uri(path)?;
         let params = DidChangeTextDocumentParams {
             text_document: VersionedTextDocumentIdentifier {
-                uri: path_to_uri(path).unwrap(),
+                uri,
                 version: self.get_next_version(path) as i32,
             },
             content_changes,
         };
 
         self.send_notification::<DidChangeTextDocument>(params);
+        Ok(())
     }
 
     pub async fn completion(
@@ -536,17 +540,16 @@ mod tests {
             None,
         )?;
 
-        let dir = std::env::current_dir()
-            .unwrap()
+        let dir = std::env::current_dir()?
             .to_string_lossy()
             .into_owned();
 
-        lsp.init(&dir).await;
+        lsp.init(&dir).await?;
 
         let content = r#"for i in range(10000): print(i)"#;
         let file_path = "fast.py";
 
-        lsp.did_open(lang, file_path, content);
+        lsp.did_open(lang, file_path, content)?;
 
         // Test completion on 'range'
         let completions = lsp.completion(file_path, 0, 12).await?;
@@ -665,8 +668,8 @@ pub mod lsp_messages {
         }
     }
 
-    pub fn initialize(dir: &str, lsp_name: Option<&str>) -> String {
-        let uri: Uri = path_to_uri(dir).unwrap();
+    pub fn initialize(dir: &str, lsp_name: Option<&str>) -> Result<String> {
+        let uri: Uri = path_to_uri(dir)?;
 
         let path = std::path::Path::new(dir);
         let folder_name = path
@@ -743,7 +746,7 @@ pub mod lsp_messages {
             "params": params
         });
 
-        to_string(&request).unwrap()
+        Ok(to_string(&request)?)
     }
 }
 
@@ -804,7 +807,10 @@ impl LspManager {
             .to_string_lossy()
             .into_owned();
 
-        lsp.init(&dir).await;
+        if let Err(e) = lsp.init(&dir).await {
+            error!("error initializing lsp process {}: {}", &lsp_cmd, e);
+            return;
+        }
 
         self.lang2lsp.insert(lang, lsp);
     }
diff --git a/anycode-backend/src/main.rs b/anycode-backend/src/main.rs
@@ -9,7 +9,7 @@ use socketioxide::{
 };
 use tower::ServiceBuilder;
 use tower_http::cors::CorsLayer;
-use tracing::info;
+use tracing::{error, info};
 
 mod acp;
 mod acp_fs;
@@ -151,7 +151,9 @@ async fn on_disconnect(socket: SocketRef, state: State<AppState>) {
 
         for (file_path, lang) in &files_to_close {
             if let Some(lsp) = lsp_manager.get(lang).await {
-                lsp.did_close(file_path);
+                if let Err(e) = lsp.did_close(file_path) {
+                    error!("Failed to notify LSP didClose for {}: {:?}", file_path, e);
+                }
                 // f2c.remove(file_path);
             }
         }
