fix: batch merge of bug fixes (PR #289) - issues #2782, #2783, #2784, #2785, #2786, #2788, #2789, #2791, #2792

Fixes:
- #2782: Ctrl+W now correctly deletes word backward in TUI input
- #2783: Insert key is now handled (placeholder for future overwrite mode)
- #2784: Double-click now selects word at cursor in input field
- #2785: Terminal state is properly saved/restored on Ctrl+Z suspend/resume
- #2786: Windows console now enables VT processing for ANSI sequences
- #2788: Improved async task cancellation with proper HTTP connection cleanup
- #2789: Added graceful shutdown for WebSocket/HTTP sessions on server exit
- #2791: MCP child processes now have filtered environment (no secrets)
- #2792: TUI streaming output optimized with dirty tracking, reduced idle FPS

Author: factorydroid

Cargo.lock

@@ -64,8 +64,9 @@ where
         warn!("Use --auth to enable authentication.");
     }
 
-    let state = AppState::new(config.clone()).await?;
-    let app = create_router(state);
+    let state = Arc::new(AppState::new(config.clone()).await?);
+    let state_for_cleanup = Arc::clone(&state);
+    let app = create_router_with_state(state);
 
     let addr: SocketAddr = config.listen_addr.parse()?;
     info!("Starting Cortex server on {}", addr);
@@ -102,6 +103,11 @@ where
         .with_graceful_shutdown(shutdown)
         .await?;
 
+    // Graceful shutdown: close all active sessions first
+    // This ensures WebSocket clients receive proper close frames
+    info!("Server shutting down, cleaning up active sessions...");
+    state_for_cleanup.cli_session_manager.shutdown_all().await;
+
     // Cleanup mDNS on shutdown
     if let Some(publisher) = mdns_publisher {
         if let Err(e) = publisher.unpublish().await {
@@ -117,6 +123,14 @@ where
 
 /// Create the application router.
 pub fn create_router(state: AppState) -> Router {
+    create_router_with_state(Arc::new(state))
+}
+
+/// Create the application router with an Arc-wrapped state.
+///
+/// This variant is useful when you need to keep a reference to the state
+/// for cleanup purposes (e.g., during graceful shutdown).
+pub fn create_router_with_state(state: Arc<AppState>) -> Router {
     let api_routes = api::routes()
         .merge(websocket::routes())
         .merge(streaming::routes())
@@ -127,5 +141,5 @@ pub fn create_router(state: AppState) -> Router {
         .nest("/api/v1", api_routes)
         .layer(TraceLayer::new_for_http())
         .layer(CorsLayer::permissive())
-        .with_state(Arc::new(state))
+        .with_state(state)
 }

cortex-app-server/src/lib.rs

@@ -411,6 +411,33 @@ impl SessionManager {
         }
     }
 
+    /// Gracefully shutdown all active sessions.
+    ///
+    /// This method should be called during server shutdown to ensure all
+    /// WebSocket connections receive proper close frames and all in-progress
+    /// requests are terminated cleanly.
+    pub async fn shutdown_all(&self) {
+        let session_ids: Vec<String> = {
+            let sessions = self.sessions.read().await;
+            sessions.keys().cloned().collect()
+        };
+
+        if session_ids.is_empty() {
+            info!("No active sessions to shutdown");
+            return;
+        }
+
+        info!("Shutting down {} active sessions", session_ids.len());
+
+        for session_id in session_ids {
+            if let Err(e) = self.destroy_session(&session_id).await {
+                warn!("Failed to shutdown session {}: {}", session_id, e);
+            }
+        }
+
+        info!("All sessions shutdown complete");
+    }
+
     /// List all active sessions.
     pub async fn list_sessions(&self) -> Vec<SessionInfo> {
         let sessions = self.sessions.read().await;

cortex-app-server/src/session_manager.rs

@@ -97,6 +97,47 @@ impl CliSessionManager {
         let sessions = self.sessions.read().await;
         sessions.len()
     }
+
+    /// Gracefully shutdown all active CLI sessions.
+    ///
+    /// This method should be called during server shutdown to ensure all
+    /// streaming connections receive proper close frames and all in-progress
+    /// requests are terminated cleanly.
+    pub async fn shutdown_all(&self) {
+        let session_ids: Vec<String> = {
+            let sessions = self.sessions.read().await;
+            sessions.keys().cloned().collect()
+        };
+
+        if session_ids.is_empty() {
+            info!("No active CLI sessions to shutdown");
+            return;
+        }
+
+        info!("Shutting down {} active CLI sessions", session_ids.len());
+
+        let mut sessions = self.sessions.write().await;
+        for session_id in session_ids {
+            if let Some(session) = sessions.remove(&session_id) {
+                // Send shutdown command
+                let _ = session
+                    .handle
+                    .submission_tx
+                    .send(Submission {
+                        id: Uuid::new_v4().to_string(),
+                        op: Op::Shutdown,
+                    })
+                    .await;
+
+                // Abort the session task
+                session.session_task.abort();
+
+                debug!(session_id = %session_id, "CLI session shutdown");
+            }
+        }
+
+        info!("All CLI sessions shutdown complete");
+    }
 }
 
 // ============================================================================

cortex-app-server/src/streaming.rs

@@ -13,7 +13,7 @@ doctest = false
 [dependencies]
 ratatui = { workspace = true }
 crossterm = { workspace = true }
-tokio = { workspace = true, features = ["full", "sync", "time", "macros", "rt-multi-thread"] }
+tokio = { workspace = true, features = ["full", "sync", "time", "macros", "rt-multi-thread", "signal"] }
 unicode-width = { workspace = true }
 pulldown-cmark = { workspace = true }
 image = { workspace = true }
@@ -22,6 +22,9 @@ anyhow = { workspace = true }
 futures = { workspace = true }
 tracing = { workspace = true }
 
+[target.'cfg(unix)'.dependencies]
+libc = "0.2"
+
 # Markdown rendering dependencies
 opentui-syntax = { workspace = true }
 opentui-text = { workspace = true }

cortex-core/Cargo.toml

@@ -89,6 +89,14 @@ pub enum EngineEvent {
     ///
     /// Contains the pasted text content.
     Paste(String),
+
+    /// The process was suspended (SIGTSTP / Ctrl+Z on Unix).
+    /// The application should save terminal state before this.
+    Suspend,
+
+    /// The process was resumed (SIGCONT on Unix).
+    /// The application should restore terminal state after this.
+    Resume,
 }
 
 /// High-performance frame engine for TUI applications.
@@ -210,6 +218,7 @@ impl FrameEngine {
     /// 1. **Tick events**: Generated at the configured tick rate
     /// 2. **Terminal events**: Keyboard, mouse, and resize events from crossterm
     /// 3. **Shutdown**: Monitors the running flag for graceful termination
+    /// 4. **Unix signals**: SIGTSTP (Ctrl+Z) and SIGCONT for suspend/resume
     ///
     /// # Errors
     ///
@@ -230,43 +239,126 @@ impl FrameEngine {
         // Create the crossterm event stream
         let mut event_stream = EventStream::new();
 
+        // Set up Unix signal handlers for suspend/resume (Ctrl+Z)
+        #[cfg(unix)]
+        let mut sigtstp =
+            tokio::signal::unix::signal(tokio::signal::unix::SignalKind::from_raw(libc::SIGTSTP))
+                .ok();
+
+        #[cfg(unix)]
+        let mut sigcont =
+            tokio::signal::unix::signal(tokio::signal::unix::SignalKind::from_raw(libc::SIGCONT))
+                .ok();
+
         // Main event loop using tokio::select!
+        // On Unix, we also handle SIGTSTP (Ctrl+Z suspend) and SIGCONT (resume) signals
         while self.running.load(Ordering::SeqCst) {
             let tick_interval = self
                 .tick_interval
                 .as_mut()
                 .expect("tick interval initialized");
 
-            tokio::select! {
-                // Branch 1: Tick interval for animations
-                _ = tick_interval.tick() => {
-                    self.frame_count = self.frame_count.wrapping_add(1);
-                    self.send_event(EngineEvent::Tick(self.frame_count)).await?;
-                }
+            // Platform-specific select to handle signals on Unix
+            #[cfg(unix)]
+            {
+                // Create futures for signal handling (always pending if signal registration failed)
+                let sigtstp_fut = async {
+                    if let Some(ref mut sig) = sigtstp {
+                        sig.recv().await
+                    } else {
+                        std::future::pending().await
+                    }
+                };
+                let sigcont_fut = async {
+                    if let Some(ref mut sig) = sigcont {
+                        sig.recv().await
+                    } else {
+                        std::future::pending().await
+                    }
+                };
+
+                tokio::select! {
+                    // Branch 1: Tick interval for animations
+                    _ = tick_interval.tick() => {
+                        self.frame_count = self.frame_count.wrapping_add(1);
+                        self.send_event(EngineEvent::Tick(self.frame_count)).await?;
+                    }
 
-                // Branch 2: Terminal events from crossterm
-                maybe_event = event_stream.next() => {
-                    match maybe_event {
-                        Some(Ok(event)) => {
-                            if let Some(engine_event) = self.translate_event(event) {
-                                // Check for quit before sending
-                                let is_quit = matches!(engine_event, EngineEvent::Quit);
-                                self.send_event(engine_event).await?;
-
-                                if is_quit {
-                                    self.running.store(false, Ordering::SeqCst);
+                    // Branch 2: Terminal events from crossterm
+                    maybe_event = event_stream.next() => {
+                        match maybe_event {
+                            Some(Ok(event)) => {
+                                if let Some(engine_event) = self.translate_event(event) {
+                                    // Check for quit before sending
+                                    let is_quit = matches!(engine_event, EngineEvent::Quit);
+                                    self.send_event(engine_event).await?;
+
+                                    if is_quit {
+                                        self.running.store(false, Ordering::SeqCst);
+                                    }
                                 }
                             }
+                            Some(Err(e)) => {
+                                // Send error event but continue running
+                                let error_msg = format!("Event stream error: {e}");
+                                self.send_event(EngineEvent::Error(error_msg)).await?;
+                            }
+                            None => {
+                                // Event stream ended - this typically means terminal closed
+                                self.send_event(EngineEvent::Quit).await?;
+                                self.running.store(false, Ordering::SeqCst);
+                            }
                         }
-                        Some(Err(e)) => {
-                            // Send error event but continue running
-                            let error_msg = format!("Event stream error: {e}");
-                            self.send_event(EngineEvent::Error(error_msg)).await?;
-                        }
-                        None => {
-                            // Event stream ended - this typically means terminal closed
-                            self.send_event(EngineEvent::Quit).await?;
-                            self.running.store(false, Ordering::SeqCst);
+                    }
+
+                    // Branch 3: SIGTSTP (Ctrl+Z suspend)
+                    _ = sigtstp_fut => {
+                        // Send suspend event so the application can save terminal state
+                        self.send_event(EngineEvent::Suspend).await?;
+                    }
+
+                    // Branch 4: SIGCONT (resume after suspend)
+                    _ = sigcont_fut => {
+                        // Send resume event so the application can restore terminal state
+                        self.send_event(EngineEvent::Resume).await?;
+                    }
+                }
+            }
+
+            // Non-Unix platforms: no signal handling
+            #[cfg(not(unix))]
+            {
+                tokio::select! {
+                    // Branch 1: Tick interval for animations
+                    _ = tick_interval.tick() => {
+                        self.frame_count = self.frame_count.wrapping_add(1);
+                        self.send_event(EngineEvent::Tick(self.frame_count)).await?;
+                    }
+
+                    // Branch 2: Terminal events from crossterm
+                    maybe_event = event_stream.next() => {
+                        match maybe_event {
+                            Some(Ok(event)) => {
+                                if let Some(engine_event) = self.translate_event(event) {
+                                    // Check for quit before sending
+                                    let is_quit = matches!(engine_event, EngineEvent::Quit);
+                                    self.send_event(engine_event).await?;
+
+                                    if is_quit {
+                                        self.running.store(false, Ordering::SeqCst);
+                                    }
+                                }
+                            }
+                            Some(Err(e)) => {
+                                // Send error event but continue running
+                                let error_msg = format!("Event stream error: {e}");
+                                self.send_event(EngineEvent::Error(error_msg)).await?;
+                            }
+                            None => {
+                                // Event stream ended - this typically means terminal closed
+                                self.send_event(EngineEvent::Quit).await?;
+                                self.running.store(false, Ordering::SeqCst);
+                            }
                         }
                     }
                 }