Update backend and layout/editor state handling

Author: vipmax

anycode-backend/src/acp.rs

@@ -1139,6 +1139,7 @@ pub struct AcpAgent {
     prompt_sender: Option<mpsc::Sender<String>>,
     config_sender: Option<mpsc::Sender<PendingConfigUpdate>>,
     cancel_sender: Arc<tokio::sync::Mutex<Option<mpsc::Sender<()>>>>,
+    shutdown_sender: Option<mpsc::Sender<()>>,
     process_handle: Option<tokio::task::JoinHandle<()>>,
     io_handle: Option<tokio::task::JoinHandle<()>>,
     history: Arc<tokio::sync::Mutex<Vec<AcpMessage>>>,
@@ -1174,6 +1175,7 @@ impl AcpAgent {
             prompt_sender: None,
             config_sender: None,
             cancel_sender: Arc::new(tokio::sync::Mutex::new(None)),
+            shutdown_sender: None,
             process_handle: None,
             io_handle: None,
             history: Arc::new(tokio::sync::Mutex::new(Vec::new())),
@@ -1203,6 +1205,8 @@ impl AcpAgent {
             let mut cancel_sender_guard = self.cancel_sender.lock().await;
             *cancel_sender_guard = Some(cancel_tx.clone());
         }
+        let (shutdown_tx, mut shutdown_rx) = mpsc::channel::<()>(1);
+        self.shutdown_sender = Some(shutdown_tx);
 
         let (bootstrap_tx, bootstrap_rx) = oneshot::channel::<Result<SessionBootstrap>>();
 
@@ -1250,8 +1254,21 @@ impl AcpAgent {
         self.connection = None;
 
         let process_handle = tokio::spawn(async move {
-            let _ = child.wait().await;
-            debug!("ACP agent process ended");
+            tokio::select! {
+                result = child.wait() => {
+                    if let Err(err) = result {
+                        debug!("ACP agent process wait failed: {}", err);
+                    }
+                    debug!("ACP agent process ended");
+                }
+                _ = shutdown_rx.recv() => {
+                    if let Err(err) = child.kill().await {
+                        debug!("ACP agent process kill failed: {}", err);
+                    }
+                    let _ = child.wait().await;
+                    debug!("ACP agent process stopped manually");
+                }
+            }
         });
         self.process_handle = Some(process_handle);
 
@@ -1967,8 +1984,11 @@ impl AcpAgent {
 
     pub async fn stop(&mut self) {
         self.ready.store(false, Ordering::SeqCst);
+        if let Some(shutdown_tx) = self.shutdown_sender.take() {
+            let _ = shutdown_tx.send(()).await;
+        }
         if let Some(handle) = self.process_handle.take() {
-            handle.abort();
+            let _ = handle.await;
         }
         if let Some(handle) = self.io_handle.take() {
             handle.abort();
@@ -2182,6 +2202,13 @@ impl AcpManager {
         }
     }
 
+    pub async fn stop_all(&mut self) {
+        let agent_ids: Vec<String> = self.agents.keys().cloned().collect();
+        for agent_id in agent_ids {
+            self.stop_agent(&agent_id).await;
+        }
+    }
+
     /// Cancel current prompt for agent by agent_id.
     pub async fn cancel_prompt(&self, agent_id: &str) -> Result<()> {
         if let Some(agent) = self.agents.get(agent_id) {

anycode-backend/src/app_state.rs

@@ -37,6 +37,25 @@ pub struct TerminalData {
     pub buffer: Arc<Mutex<VecDeque<String>>>,
 }
 
+impl AppState {
+    pub async fn shutdown(&self) {
+        self.lsp_manager.lock().await.stop_all().await;
+        self.acp_manager.lock().await.stop_all().await;
+
+        let terminal_handles = self
+            .terminals
+            .lock()
+            .await
+            .values()
+            .cloned()
+            .collect::<Vec<_>>();
+
+        for terminal in terminal_handles {
+            let _ = terminal.terminal.kill().await;
+        }
+    }
+}
+
 #[macro_export]
 macro_rules! error_ack {
     ($ack:expr, $path:expr, $msg:expr $(, $args:expr)*) => {{

anycode-backend/src/lsp.rs

@@ -162,7 +162,10 @@ impl Lsp {
                     debug!("lsp process wait done");
                 }
                 _ = kill_recv.recv() => {
-                    child.kill().await.expect("kill failed");
+                    if let Err(err) = child.kill().await {
+                        debug!("lsp process kill failed: {}", err);
+                    }
+                    let _ = child.wait().await;
                     debug!("lsp process killed manually");
                 }
             }
@@ -831,4 +834,11 @@ impl LspManager {
             info!("stopped lsp: {}", lang);
         }
     }
+
+    pub async fn stop_all(&mut self) {
+        let langs: Vec<String> = self.lang2lsp.keys().cloned().collect();
+        for lang in langs {
+            self.stop(&lang).await;
+        }
+    }
 }

anycode-backend/src/main.rs

@@ -255,7 +255,7 @@ async fn main() -> Result<()> {
     let acp_fs_lsp = state.lsp_manager.clone();
     let acp_fs_config = state.config.clone();
 
-    let (layer, io) = SocketIo::builder().with_state(state).build_layer();
+    let (layer, io) = SocketIo::builder().with_state(state.clone()).build_layer();
     let cors = ServiceBuilder::new()
         .layer(CorsLayer::permissive())
         .layer(layer);
@@ -343,5 +343,7 @@ async fn main() -> Result<()> {
         })
         .await?;
 
+    state.shutdown().await;
+
     Ok(())
 }

anycode-backend/src/terminal.rs

@@ -137,6 +137,7 @@ impl Terminal {
                     }
                     Some(_) = kill_rx.recv() => {
                         let _ = child.kill();
+                        let _ = child.wait();
                         break;
                     }
                     else => break,

anycode/App.tsx

@@ -49,10 +49,6 @@ const App: React.FC = () => {
         wsRef,
         isConnected,
         diffEnabled,
-        onFileClosed: (fileId: string) => {
-            const node = fileTree.findNodeByPath(fileTree.fileTree, fileId);
-            if (node) fileTree.clearFileSelection();
-        },
     });
 
     const terminals = useTerminals({ wsRef, isConnected });
@@ -181,23 +177,27 @@ const App: React.FC = () => {
         search.startSearch(pattern);
     };
 
+    const resolveEditorPaneId = useCallback(() => {
+        return layoutActionsRef.current?.ensureEditorPanel(editors.activeEditorPaneId);
+    }, [editors]);
+
     const handleOpenFile = useCallback((path: string, line?: number, column?: number) => {
-        const paneId = layoutActionsRef.current?.ensureEditorPanel();
+        const paneId = resolveEditorPaneId();
         if (!paneId) return;
         editors.openFile(path, line, column, paneId);
-    }, [editors]);
+    }, [editors, resolveEditorPaneId]);
 
     const handleOpenFileDiff = useCallback((path: string, line?: number, column?: number) => {
-        const paneId = layoutActionsRef.current?.ensureEditorPanel();
+        const paneId = resolveEditorPaneId();
         if (!paneId) return;
         editors.openFileDiff(path, line, column, paneId);
-    }, [editors]);
+    }, [editors, resolveEditorPaneId]);
 
     const handleSelectFile = useCallback((fileId: string) => {
-        const paneId = layoutActionsRef.current?.ensureEditorPanel();
+        const paneId = resolveEditorPaneId();
         if (!paneId) return;
         editors.setActiveFileId(fileId, paneId);
-    }, [editors]);
+    }, [editors, resolveEditorPaneId]);
 
     const handleSearchResultClick = (filePath: string, match: SearchMatch) => {
         handleOpenFile(filePath, match.line, match.column);

anycode/components/layout/Layout.css

@@ -144,7 +144,7 @@
 
 .layout .dv-split-view-container .dv-view {
     padding: 0 !important;
-    overflow: visible !important;
+    overflow: hidden !important;
     background-color: transparent !important;
     box-sizing: border-box !important;
 }