feat: add customizable system monitoring position

- Add settings to position the system monitoring panel at the Bottom, Sidebar, or Hidden.
- Support dynamically reallocating UI space when the monitor panel is moved.
- Implement a simplified, compact card-style system monitoring view for the sidebar (similar to v0.3.5 design).
- Add full localization for monitoring setting and sidebar metrics.

locales/en.yml

@@ -68,6 +68,10 @@ system_default: "System Default"
 ui_font_family: "UI Font"
 terminal_font_family: "Terminal Font"
 theme_management_hint: "Theme mode and light/dark theme families are managed from the top-bar theme button."
+monitoring_position: "Monitoring Position"
+position_bottom: "Bottom"
+position_sidebar: "Sidebar"
+position_hidden: "Hidden"
 local_host: "local host"
 local_terminal_opened: "local terminal opened"
 connecting: "Connecting"

locales/zh-CN.yml

@@ -69,7 +69,11 @@ terminal_font_size: "终端字体大小"
 system_default: "系统默认"
 ui_font_family: "界面字体"
 terminal_font_family: "终端字体"
-theme_management_hint: "主题模式和亮/暗主题系列可通过顶栏的主题按钮管理。"
+theme_management_hint: "深色/浅色模式以及主题配色由顶部栏的样式按钮统一管理。"
+monitoring_position: "系统监控显示位置"
+position_bottom: "底部"
+position_sidebar: "侧边栏"
+position_hidden: "不显示"
 local_host: "本地主机"
 local_terminal_opened: "已打开本地终端"
 connecting: "正在连接"

src/app.rs

@@ -0,0 +1,667 @@
+use std::{
+    cell::{Cell, RefCell},
+    collections::HashMap,
+    ops::Range,
+    rc::Rc,
+    sync::mpsc,
+    time::{Duration, Instant},
+};
+
+use gpui::{
+    AppContext as _, Bounds, Context, Entity, FocusHandle, Pixels, Point,
+    SharedString, Size, UniformListScrollHandle, Window, point,
+    px, size,
+};
+use gpui_component::{
+    Theme, ThemeMode, ThemeRegistry,
+    input::{InputEvent, InputState},
+    resizable::ResizableState,
+    scroll::ScrollbarHandle,
+};
+use rust_i18n::t;
+use tokio::runtime::Runtime;
+
+use crate::{
+    config::{AuthMethod, ConfigStore},
+    sftp::SftpHandle,
+    system::{SystemSampler, SystemSnapshot},
+    terminal::{self, BackendEvent, TabKind, TerminalTab},
+    ssh_terminal,
+};
+
+pub(crate) struct TerminalScrollbarState {
+    line_height: Pixels,
+    total_lines: usize,
+    viewport_lines: usize,
+    display_offset: usize,
+}
+
+#[derive(Clone, Default)]
+pub(crate) struct TerminalScrollbarHandle {
+    state: Rc<RefCell<Option<TerminalScrollbarState>>>,
+    pub(crate) future_display_offset: Rc<Cell<Option<usize>>>,
+}
+
+impl TerminalScrollbarHandle {
+    pub(crate) fn update(&self, snapshot: &terminal::RenderSnapshot, line_height: Pixels) {
+        self.state.replace(Some(TerminalScrollbarState {
+            line_height,
+            total_lines: snapshot.history_size + snapshot.rows,
+            viewport_lines: snapshot.rows,
+            display_offset: snapshot.display_offset,
+        }));
+    }
+}
+
+impl ScrollbarHandle for TerminalScrollbarHandle {
+    fn offset(&self) -> Point<Pixels> {
+        let state_ref = self.state.borrow();
+        let Some(state) = state_ref.as_ref() else {
+            return point(px(0.), px(0.));
+        };
+        let scroll_offset = state
+            .total_lines
+            .saturating_sub(state.viewport_lines)
+            .saturating_sub(state.display_offset);
+        point(px(0.), -(scroll_offset as f32 * state.line_height))
+    }
+
+    fn set_offset(&self, offset: Point<Pixels>) {
+        let state_ref = self.state.borrow();
+        let Some(state) = state_ref.as_ref() else {
+            return;
+        };
+        let offset_delta = (offset.y / state.line_height).round() as i32;
+        let max_offset = state.total_lines.saturating_sub(state.viewport_lines);
+        let display_offset = (max_offset as i32 + offset_delta).clamp(0, max_offset as i32);
+        self.future_display_offset
+            .set(Some(display_offset as usize));
+    }
+
+    fn content_size(&self) -> Size<Pixels> {
+        let state_ref = self.state.borrow();
+        let Some(state) = state_ref.as_ref() else {
+            return size(px(0.), px(0.));
+        };
+        size(
+            px(0.),
+            state.total_lines.max(state.viewport_lines) as f32 * state.line_height,
+        )
+    }
+}
+
+
+
+pub(crate) struct Ashell {
+    pub(crate) focus_handle: FocusHandle,
+    pub(crate) selector_focus_handle: FocusHandle,
+    pub(crate) host_input: Entity<InputState>,
+    pub(crate) session_name_input: Entity<InputState>,
+    pub(crate) port_input: Entity<InputState>,
+    pub(crate) user_input: Entity<InputState>,
+    pub(crate) password_input: Entity<InputState>,
+    pub(crate) key_path_input: Entity<InputState>,
+    pub(crate) key_inline_input: Entity<InputState>,
+    pub(crate) sftp_path_input: Entity<InputState>,
+    pub(crate) ssh_auth_method: AuthMethod,
+    pub(crate) editing_session_id: Option<String>,
+    pub(crate) follow_system_theme: bool,
+    pub(crate) theme_mode: ThemeMode,
+    pub(crate) light_theme_name: SharedString,
+    pub(crate) dark_theme_name: SharedString,
+    pub(crate) ui_font_size: f32,
+    pub(crate) terminal_font_size: f32,
+    pub(crate) ui_font_family: SharedString,
+    pub(crate) terminal_font_family: SharedString,
+    pub(crate) tabs: Vec<TerminalTab>,
+    pub(crate) sftp_handles: HashMap<String, SftpHandle>,
+    pub(crate) active_tab: Option<String>,
+    pub(crate) selector_selection: usize,
+    pub(crate) workspace_panels: Entity<ResizableState>,
+    pub(crate) body_panels: Entity<ResizableState>,
+    pub(crate) terminal_scrollbar: TerminalScrollbarHandle,
+    pub(crate) remote_files_scroll_handle: UniformListScrollHandle,
+    pub(crate) disk_scroll_handle: gpui::ScrollHandle,
+    pub(crate) tabs_scroll_handle: gpui::ScrollHandle,
+    pub(crate) selector_scroll_handle: gpui::ScrollHandle,
+    pub(crate) saved_scroll_handle: gpui::ScrollHandle,
+    pub(crate) connection_progress: Option<ConnectionProgress>,
+    pub(crate) pending_sftp_path_sync: Option<String>,
+    pub(crate) sftp_context_menu: Option<SftpContextMenuState>,
+    pub(crate) sftp_creating_folder: bool,
+    pub(crate) sftp_new_folder_input: Entity<InputState>,
+    pub(crate) sftp_delete_scroll_handle: gpui::ScrollHandle,
+    pub(crate) show_hidden_files: bool,
+    pub(crate) transfers: Vec<crate::terminal::Transfer>,
+    pub(crate) show_transfers_dialog: bool,
+    pub(crate) system_status: Option<SharedString>,
+    pub(crate) terminal_bounds: Option<Bounds<Pixels>>,
+    pub(crate) terminal_selecting: bool,
+    pub(crate) terminal_marked_text: Option<String>,
+    pub(crate) sftp_panel_minimized: bool,
+    pub(crate) prev_monitoring_size: Option<Pixels>,
+    pub(crate) status: SharedString,
+    pub(crate) config: ConfigStore,
+    pub(crate) system_sampler: SystemSampler,
+    pub(crate) system: SystemSnapshot,
+    pub(crate) cpu_history: Vec<f32>,
+    pub(crate) net_rx_history: Vec<f32>,
+    pub(crate) net_tx_history: Vec<f32>,
+    pub(crate) last_system_sample: Instant,
+    pub(crate) last_theme_sync: Instant,
+
+    pub(crate) remote_sample_in_flight: bool,
+    pub(crate) runtime: Runtime,
+    pub(crate) events_rx: mpsc::Receiver<BackendEvent>,
+    pub(crate) events_tx: mpsc::Sender<BackendEvent>,
+    pub(crate) _subscriptions: Vec<gpui::Subscription>,
+}
+
+#[derive(Clone)]
+pub(crate) enum SelectorEntry {
+    Local,
+    NewSsh,
+    Saved(String),
+}
+
+#[derive(Clone)]
+pub(crate) struct ConnectionProgress {
+    pub(crate) tab_id: String,
+    pub(crate) title: SharedString,
+    pub(crate) lines: Vec<SharedString>,
+    pub(crate) failed: bool,
+}
+
+#[derive(Clone)]
+pub(crate) struct SftpContextMenuState {
+    pub(crate) remote_path: String,
+    pub(crate) is_dir: bool,
+    pub(crate) position: Point<Pixels>,
+}
+
+impl Ashell {
+    pub(crate) fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
+        let host_input = cx.new(|cx| InputState::new(window, cx).placeholder(t!("host")));
+        let session_name_input =
+            cx.new(|cx| InputState::new(window, cx).placeholder("name (optional)"));
+        let port_input = cx.new(|cx| InputState::new(window, cx).default_value("22"));
+        let user_input = cx.new(|cx| InputState::new(window, cx).default_value("root"));
+        let password_input = cx.new(|cx| {
+            InputState::new(window, cx)
+                .placeholder(t!("password"))
+                .masked(true)
+        });
+        let key_path_input =
+            cx.new(|cx| InputState::new(window, cx).placeholder("~/.ssh/id_ed25519"));
+        let key_inline_input = cx.new(|cx| {
+            InputState::new(window, cx)
+                .multi_line(true)
+                .rows(5)
+                .placeholder("-----BEGIN OPENSSH PRIVATE KEY-----")
+        });
+        let sftp_path_input = cx.new(|cx| InputState::new(window, cx).default_value("/"));
+        let sftp_new_folder_input = cx.new(|cx| InputState::new(window, cx).placeholder(t!("new_folder").to_string()));
+
+        let _subscriptions = vec![
+            cx.subscribe_in(&host_input, window, Self::on_input_event),
+            cx.subscribe_in(&session_name_input, window, Self::on_input_event),
+            cx.subscribe_in(&port_input, window, Self::on_input_event),
+            cx.subscribe_in(&user_input, window, Self::on_input_event),
+            cx.subscribe_in(&password_input, window, Self::on_input_event),
+            cx.subscribe_in(&key_path_input, window, Self::on_input_event),
+            cx.subscribe_in(&key_inline_input, window, Self::on_input_event),
+            cx.subscribe_in(&sftp_path_input, window, Self::on_input_event),
+            cx.subscribe_in(&sftp_new_folder_input, window, Self::on_input_event),
+        ];
+
+        let (events_tx, events_rx) = mpsc::channel();
+        let workspace_panels = cx.new(|_| ResizableState::default());
+        let body_panels = cx.new(|_| ResizableState::default());
+        let mut system_sampler = SystemSampler::new();
+        let system = system_sampler.sample();
+        let default_light_theme_name = ThemeRegistry::global(cx).default_light_theme().name.clone();
+        let default_dark_theme_name = ThemeRegistry::global(cx).default_dark_theme().name.clone();
+        let config = ConfigStore::load().unwrap_or_else(|err| {
+            tracing::warn!("failed to load config: {err:#}");
+            ConfigStore::in_memory()
+        });
+        let follow_system_theme =
+            if config.light_theme_name().is_empty() && config.dark_theme_name().is_empty() {
+                true
+            } else {
+                config.follow_system_theme()
+            };
+
+        let theme_mode = match config.theme_mode() {
+            "light" => ThemeMode::Light,
+            "dark" => ThemeMode::Dark,
+            _ => ThemeMode::Light,
+        };
+        let light_theme_name = if config.light_theme_name().is_empty() {
+            default_light_theme_name
+        } else {
+            config.light_theme_name().into()
+        };
+        let dark_theme_name = if config.dark_theme_name().is_empty() {
+            default_dark_theme_name
+        } else {
+            config.dark_theme_name().into()
+        };
+
+        let configured_locale = config.locale();
+        let mut active_locale = configured_locale.to_string();
+        if active_locale == "system" {
+            active_locale = sys_locale::get_locale().unwrap_or_else(|| "en".to_string());
+            if active_locale.starts_with("zh") {
+                active_locale = "zh-CN".to_string();
+            } else {
+                active_locale = "en".to_string();
+            }
+        }
+        rust_i18n::set_locale(&active_locale);
+        gpui_component::set_locale(&active_locale);
+        let ui_font_family: SharedString = config.ui_font_family().into();
+        let terminal_font_family: SharedString = config.terminal_font_family().into();
+        let mut this = Self {
+            focus_handle: cx.focus_handle(),
+            selector_focus_handle: cx.focus_handle(),
+            host_input,
+            session_name_input,
+            port_input,
+            user_input,
+            password_input,
+            key_path_input,
+            key_inline_input,
+            sftp_path_input,
+            ssh_auth_method: AuthMethod::Password,
+            editing_session_id: None,
+            follow_system_theme,
+            theme_mode,
+            light_theme_name,
+            dark_theme_name,
+            ui_font_size: config.ui_font_size(),
+            terminal_font_size: config.terminal_font_size(),
+            ui_font_family,
+            terminal_font_family,
+            tabs: Vec::new(),
+            sftp_handles: HashMap::new(),
+            active_tab: None,
+            selector_selection: 0,
+            workspace_panels,
+            body_panels,
+            terminal_scrollbar: TerminalScrollbarHandle::default(),
+            remote_files_scroll_handle: UniformListScrollHandle::new(),
+            disk_scroll_handle: gpui::ScrollHandle::new(),
+            tabs_scroll_handle: gpui::ScrollHandle::new(),
+            selector_scroll_handle: gpui::ScrollHandle::new(),
+            saved_scroll_handle: gpui::ScrollHandle::new(),
+            connection_progress: None,
+            pending_sftp_path_sync: Some("/".into()),
+            sftp_context_menu: None,
+            sftp_creating_folder: false,
+            sftp_new_folder_input,
+            sftp_delete_scroll_handle: gpui::ScrollHandle::new(),
+            show_hidden_files: config.show_hidden_files(),
+            transfers: config.transfers(),
+            show_transfers_dialog: false,
+            system_status: None,
+            terminal_bounds: None,
+            terminal_selecting: false,
+            terminal_marked_text: None,
+            sftp_panel_minimized: false,
+            prev_monitoring_size: None,
+            status: "ready".into(),
+            config,
+            system_sampler,
+            system,
+            cpu_history: Vec::with_capacity(20),
+            net_rx_history: Vec::with_capacity(20),
+            net_tx_history: Vec::with_capacity(20),
+            last_system_sample: Instant::now(),
+            last_theme_sync: Instant::now(),
+
+            remote_sample_in_flight: false,
+            runtime: Runtime::new().expect("create tokio runtime"),
+            events_rx,
+            events_tx,
+            _subscriptions,
+        };
+
+        this.apply_theme_preferences(window, cx);
+        // this.open_local(cx);
+        this.start_event_pump(cx);
+        this
+    }
+
+    pub(crate) fn on_input_event(
+        &mut self,
+        input: &Entity<InputState>,
+        event: &InputEvent,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        if input == &self.sftp_path_input {
+            if let InputEvent::PressEnter { .. } = event {
+                let path = self
+                    .sftp_path_input
+                    .read(cx)
+                    .text()
+                    .to_string()
+                    .trim()
+                    .to_string();
+                self.navigate_sftp(if path.is_empty() { "/".into() } else { path }, cx);
+                window.prevent_default();
+                cx.stop_propagation();
+            }
+        } else if input == &self.sftp_new_folder_input {
+            match event {
+                InputEvent::PressEnter { .. } => {
+                    let name = self.sftp_new_folder_input.read(cx).text().to_string();
+                    if !name.is_empty() {
+                        let base_path = self.sftp_path_input.read(cx).text().to_string();
+                        let path = crate::sftp::join_remote(&base_path, &name);
+                        if let Some(id) = self.active_tab.clone() {
+                            if let Some(handle) = self.sftp_handles.get(&id) {
+                                let _ = handle.commands.send(crate::sftp::SftpCommand::CreateDir(path));
+                            }
+                        }
+                    }
+                    self.sftp_creating_folder = false;
+                    window.prevent_default();
+                    cx.stop_propagation();
+                }
+                InputEvent::Blur => {
+                    self.sftp_creating_folder = false;
+                }
+                _ => {}
+            }
+        }
+        cx.notify();
+    }
+
+    pub(crate) fn start_event_pump(&self, cx: &mut Context<Self>) {
+        cx.spawn(async move |this, cx| {
+            loop {
+                cx.background_executor()
+                    .timer(Duration::from_millis(16))
+                    .await;
+                if this
+                    .update(cx, |this, cx| {
+                        this.drain_backend_events();
+                        this.sample_system_if_due();
+                        this.sync_theme_if_due(cx);
+                        cx.notify();
+                    })
+                    .is_err()
+                {
+                    break;
+                }
+            }
+        })
+        .detach();
+    }
+
+    pub(crate) fn drain_backend_events(&mut self) {
+        let mut transfers_changed = false;
+        while let Ok(event) = self.events_rx.try_recv() {
+            match event {
+                BackendEvent::Output { tab_id, bytes } => {
+                    if let Some(tab) = self.tabs.iter_mut().find(|t| t.id == tab_id) {
+                        tab.feed(&bytes);
+                    }
+                }
+                BackendEvent::Status { tab_id, text } => {
+                    if let Some(tab) = self.tabs.iter_mut().find(|t| t.id == tab_id) {
+                        tab.status = text.clone();
+                    }
+                    if let Some(progress) = self.connection_progress.as_mut() {
+                        if progress.tab_id == tab_id {
+                            progress.lines.push(text.clone().into());
+                        }
+                    }
+                    self.status = text.into();
+                }
+                BackendEvent::Connected { tab_id } => {
+                    if let Some(tab) = self.tabs.iter_mut().find(|t| t.id == tab_id) {
+                        tab.connected = true;
+                    }
+                    self.request_active_system_snapshot();
+                    if self
+                        .connection_progress
+                        .as_ref()
+                        .is_some_and(|progress| progress.tab_id == tab_id)
+                    {
+                        self.connection_progress = None;
+                    }
+                }
+                BackendEvent::SftpEntries {
+                    tab_id,
+                    path,
+                    entries,
+                } => {
+                    if let Some(tab) = self.tabs.iter_mut().find(|t| t.id == tab_id) {
+                        if let Some(sftp) = tab.sftp.as_mut() {
+                            sftp.current_path = path;
+                            sftp.entries = entries;
+                            if self.active_tab.as_deref() == Some(tab_id.as_str()) {
+                                self.pending_sftp_path_sync = Some(sftp.current_path.clone());
+                            }
+                        }
+                    }
+                }
+                BackendEvent::SftpPreview { tab_id, preview } => {
+                    if let Some(tab) = self.tabs.iter_mut().find(|t| t.id == tab_id) {
+                        if let Some(sftp) = tab.sftp.as_mut() {
+                            sftp.selected_path = Some(preview.path.clone());
+                            sftp.preview = Some(preview);
+                        }
+                    }
+                }
+                BackendEvent::SftpStatus { tab_id, text } => {
+                    if let Some(tab) = self.tabs.iter_mut().find(|t| t.id == tab_id) {
+                        if let Some(sftp) = tab.sftp.as_mut() {
+                            sftp.status = text.clone();
+                        }
+                    }
+                    self.status = text.into();
+                }
+                BackendEvent::RemoteSystem { tab_id, snapshot } => {
+                    self.remote_sample_in_flight = false;
+                    if self.active_tab.as_deref() == Some(tab_id.as_str()) {
+                        self.system_status = None;
+                        self.system = snapshot.clone();
+                        self.cpu_history.push(snapshot.cpu_percent);
+                        if self.cpu_history.len() > 20 {
+                            self.cpu_history.remove(0);
+                        }
+                        self.net_rx_history.push(snapshot.net_rx_rate as f32);
+                        if self.net_rx_history.len() > 20 {
+                            self.net_rx_history.remove(0);
+                        }
+                        self.net_tx_history.push(snapshot.net_tx_rate as f32);
+                        if self.net_tx_history.len() > 20 {
+                            self.net_tx_history.remove(0);
+                        }
+                    }
+                }
+                BackendEvent::RemoteSystemUnavailable { tab_id, reason } => {
+                    self.remote_sample_in_flight = false;
+                    if self.active_tab.as_deref() == Some(tab_id.as_str()) {
+                        self.system_status = Some(reason.clone().into());
+                        self.status = reason.into();
+                    }
+                }
+                BackendEvent::Closed { tab_id, reason } => {
+                    self.remote_sample_in_flight = false;
+                    let mut tab_title = None;
+                    let mut session_label = None;
+                    if let Some(tab) = self.tabs.iter_mut().find(|t| t.id == tab_id) {
+                        tab.connected = false;
+                        tab.status = reason.clone();
+                        tab_title = Some(tab.title.clone());
+                        session_label = tab.session.as_ref().map(|session| {
+                            format!("{}@{}:{}", session.user, session.host, session.port)
+                        });
+                    }
+                    if self.active_tab.as_deref() == Some(tab_id.as_str()) {
+                        self.system_status = Some(reason.clone().into());
+                    }
+                    let is_graceful_exit = reason == "Terminal process exited"
+                        || reason == "SSH session exited";
+                    if let Some(progress) = self.connection_progress.as_mut() {
+                        if progress.tab_id == tab_id {
+                            progress.lines.push(reason.clone().into());
+                            let _ = session_label;
+                            let _ = tab_title;
+                            progress.title = t!("connection_failed").into();
+                            progress.failed = true;
+                        }
+                    } else if let Some(_) = session_label {
+                        if !is_graceful_exit {
+                            self.connection_progress = Some(ConnectionProgress {
+                                tab_id: tab_id.clone(),
+                                title: t!("connection_failed").into(),
+                                lines: vec![reason.clone().into()],
+                                failed: true,
+                            });
+                        }
+                    }
+                    self.status = reason.into();
+                }
+                BackendEvent::TransferProgress {
+                    tab_id: _,
+                    id,
+                    transferred,
+                    total,
+                    state,
+                } => {
+                    if let Some(t) = self.transfers.iter_mut().find(|t| t.info.id == id) {
+                        t.transferred = transferred;
+                        if let Some(total) = total {
+                            t.total = Some(total);
+                        }
+                        t.state = state;
+                        transfers_changed = true;
+                    }
+                }
+                BackendEvent::TransferStarted { tab_id, info } => {
+                    let tab_title = self
+                        .tabs
+                        .iter()
+                        .find(|t| t.id == tab_id)
+                        .map(|t| t.title.clone())
+                        .unwrap_or_else(|| "Unknown".to_string());
+                    self.transfers.insert(
+                        0,
+                        crate::terminal::Transfer {
+                            tab_id,
+                            tab_title,
+                            info,
+                            transferred: 0,
+                            total: None,
+                            state: crate::terminal::TransferState::Running,
+                        },
+                    );
+                    transfers_changed = true;
+                }
+                BackendEvent::SftpHome { tab_id, home } => {
+                    if let Some(tab) = self.tabs.iter_mut().find(|t| t.id == tab_id) {
+                        if let Some(sftp) = tab.sftp.as_mut() {
+                            sftp.home_dir = home;
+                        }
+                    }
+                }
+                BackendEvent::TerminalTitleChanged { tab_id, title } => {
+                    if let Some(tab) = self.tabs.iter_mut().find(|t| t.id == tab_id) {
+                        tab.title = title.clone();
+                    }
+                }
+            }
+        }
+        if transfers_changed {
+            self.config.set_transfers(self.transfers.clone());
+        }
+    }
+
+    pub(crate) fn sample_system_if_due(&mut self) {
+        if self.last_system_sample.elapsed() >= SystemSampler::interval() {
+            self.last_system_sample = Instant::now();
+            // When an SSH tab is active with remote data flowing, don't push
+            // local machine data into history. Instead trigger a remote fetch
+            // so both the current values and history reflect the remote server.
+            if matches!(self.active_kind(), Some(TabKind::Ssh)) && self.system_status.is_none() {
+                self.request_active_system_snapshot();
+                return;
+            }
+            let snapshot = self.system_sampler.sample();
+            let cpu_usage = snapshot.cpu_percent;
+            self.cpu_history.push(cpu_usage);
+            if self.cpu_history.len() > 20 {
+                self.cpu_history.remove(0);
+            }
+            self.net_rx_history.push(snapshot.net_rx_rate as f32);
+            if self.net_rx_history.len() > 20 {
+                self.net_rx_history.remove(0);
+            }
+            self.net_tx_history.push(snapshot.net_tx_rate as f32);
+            if self.net_tx_history.len() > 20 {
+                self.net_tx_history.remove(0);
+            }
+            self.system = snapshot;
+        }
+    }
+
+    pub(crate) fn sync_theme_if_due(&mut self, cx: &mut Context<Self>) {
+        if self.follow_system_theme && self.last_theme_sync.elapsed() >= Duration::from_secs(1) {
+            self.last_theme_sync = Instant::now();
+            Theme::sync_system_appearance(None, cx);
+            cx.refresh_windows();
+        }
+    }
+
+    pub(crate) fn request_active_system_snapshot(&mut self) {
+        if let Some((tab_id, session)) = self.active_ssh_session() {
+            if self.remote_sample_in_flight {
+                return;
+            }
+            self.remote_sample_in_flight = true;
+            let events = self.events_tx.clone();
+            self.runtime.spawn(async move {
+                match ssh_terminal::sample_remote_system(session).await {
+                    Ok(snapshot) => {
+                        let _ = events.send(BackendEvent::RemoteSystem { tab_id, snapshot });
+                    }
+                    Err(err) => {
+                        let _ = events.send(BackendEvent::RemoteSystemUnavailable {
+                            tab_id,
+                            reason: format!("remote metrics unavailable: {err:#}"),
+                        });
+                    }
+                }
+            });
+        }
+    }
+
+    pub(crate) fn terminal_ime_bounds_for_range(
+        &self,
+        range_utf16: Range<usize>,
+        element_bounds: Bounds<Pixels>,
+        cell_width: f32,
+        line_height: f32,
+    ) -> Option<Bounds<Pixels>> {
+        let snapshot = self.active_snapshot()?;
+        let cursor = snapshot.cursor?;
+        let x = element_bounds.origin.x
+            + px(cell_width) * cursor.col as f32
+            + px(cell_width) * range_utf16.start as f32;
+        let y = element_bounds.origin.y
+            + px(line_height) * cursor.row as f32;
+        Some(Bounds::new(
+            point(x, y),
+            size(
+                px(cell_width),
+                px(line_height),
+            ),
+        ))
+    }
+}

src/config.rs

@@ -127,6 +127,12 @@ pub struct ConfigFile {
     pub transfers: Vec<crate::terminal::Transfer>,
     #[serde(default)]
     pub show_hidden_files: bool,
+    #[serde(default = "default_monitoring_position")]
+    pub monitoring_position: String,
+}
+
+fn default_monitoring_position() -> String {
+    "Sidebar".to_string()
 }
 
 fn default_locale() -> String {
@@ -230,6 +236,14 @@ impl ConfigStore {
         self.cache.locale = locale.to_string();
     }
 
+    pub fn monitoring_position(&self) -> &str {
+        &self.cache.monitoring_position
+    }
+
+    pub fn set_monitoring_position(&mut self, pos: &str) {
+        self.cache.monitoring_position = pos.to_string();
+    }
+
     pub fn terminal_font_size(&self) -> f32 {
         if self.cache.terminal_font_size <= 0.0 {
             default_terminal_font_size()
@@ -259,6 +273,7 @@ impl ConfigStore {
         self.cache.workspace_panels.as_ref()
     }
 
+    #[allow(dead_code)]
     pub fn body_panels(&self) -> Option<&Vec<f32>> {
         self.cache.body_panels.as_ref()
     }

src/session.rs

@@ -0,0 +1,570 @@
+use gpui::{
+    App, AppContext as _, Context, Entity, KeyDownEvent, MouseButton,
+    MouseDownEvent, SharedString, Window, px,
+};
+use gpui_component::{
+    Theme, WindowExt as _,
+    input::InputState,
+};
+use rust_i18n::t;
+use uuid::Uuid;
+
+use crate::{
+    Ashell, ConnectionProgress, SelectorEntry,
+    config::{AuthMethod, Session},
+    local_terminal,
+    sftp,
+    ssh_terminal,
+    terminal::{BackendCommand, RenderSnapshot, TabKind, TerminalTab},
+    DEFAULT_COLS, DEFAULT_ROWS, SIDEBAR_WIDTH, TAB_BAR_HEIGHT, TERMINAL_PADDING_X,
+    TERMINAL_PADDING_Y,
+};
+
+impl Ashell {
+    pub(crate) fn open_local(&mut self, cx: &mut Context<Self>) {
+        let id = Uuid::new_v4().to_string();
+        match local_terminal::spawn_local_terminal(
+            id.clone(),
+            DEFAULT_COLS,
+            DEFAULT_ROWS,
+            self.events_tx.clone(),
+        ) {
+            Ok(backend) => {
+                let title = if cfg!(windows) { "PowerShell" } else { "Local" }.to_string();
+                let mut tab =
+                    TerminalTab::new_local(id.clone(), title, backend, self.events_tx.clone());
+                tab.resize(DEFAULT_COLS, DEFAULT_ROWS);
+                self.tabs.push(tab);
+                self.active_tab = Some(id);
+                self.tabs_scroll_handle.scroll_to_item(self.tabs.len() - 1);
+                self.status = "local terminal opened".into();
+            }
+            Err(err) => {
+                self.status = format!("failed to open local terminal: {err:#}").into();
+            }
+        }
+        cx.notify();
+    }
+
+    pub(crate) fn connect_ssh(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let session_name = self.session_name_input.read(cx).value().trim().to_string();
+        let host = self.host_input.read(cx).value().trim().to_string();
+        let port = self
+            .port_input
+            .read(cx)
+            .value()
+            .trim()
+            .parse::<u16>()
+            .unwrap_or(22);
+        let user = self.user_input.read(cx).value().trim().to_string();
+        let password = self.password_input.read(cx).value().to_string();
+        let key_path = self.key_path_input.read(cx).value().trim().to_string();
+        let key_inline = self.key_inline_input.read(cx).value().to_string();
+
+        if host.is_empty() || user.is_empty() {
+            self.status = t!("host_and_user_required").into();
+            cx.notify();
+            return;
+        }
+
+        let name = if session_name.is_empty() {
+            host.clone()
+        } else {
+            session_name
+        };
+        let existing_id = self.editing_session_id.clone();
+        let existing_last_used = existing_id
+            .as_deref()
+            .and_then(|id| self.config.get(id))
+            .and_then(|session| session.last_used.clone());
+
+        let mut session = match self.ssh_auth_method {
+            AuthMethod::Password => Session::password(host, port, user, password),
+            AuthMethod::Key => {
+                if key_path.is_empty() && key_inline.trim().is_empty() {
+                    self.status = "private key path or content is required".into();
+                    cx.notify();
+                    return;
+                }
+                Session::key(host, port, user, key_path, key_inline)
+            }
+        };
+        session.name = name;
+        if let Some(id) = existing_id {
+            session.id = id;
+        }
+        session.last_used = existing_last_used;
+        self.config.upsert(session.clone());
+        if let Err(err) = self.config.save() {
+            tracing::warn!("failed to save config: {err:#}");
+        }
+
+        self.open_ssh_session(session, cx);
+        self.editing_session_id = None;
+        window.close_dialog(cx);
+    }
+
+    pub(crate) fn set_input_value(
+        input: &Entity<InputState>,
+        value: impl Into<SharedString>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        input.update(cx, |state, cx| state.set_value(value, window, cx));
+    }
+
+    pub(crate) fn reset_ssh_form(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        self.editing_session_id = None;
+        self.ssh_auth_method = AuthMethod::Password;
+        Self::set_input_value(&self.session_name_input, "", window, cx);
+        Self::set_input_value(&self.host_input, "", window, cx);
+        Self::set_input_value(&self.port_input, "22", window, cx);
+        Self::set_input_value(&self.user_input, "root", window, cx);
+        Self::set_input_value(&self.password_input, "", window, cx);
+        Self::set_input_value(&self.key_path_input, "", window, cx);
+        Self::set_input_value(&self.key_inline_input, "", window, cx);
+    }
+
+    pub(crate) fn load_session_into_form(
+        &mut self,
+        session: &Session,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.editing_session_id = Some(session.id.clone());
+        self.ssh_auth_method = session.auth;
+        Self::set_input_value(&self.session_name_input, session.name.clone(), window, cx);
+        Self::set_input_value(&self.host_input, session.host.clone(), window, cx);
+        Self::set_input_value(&self.port_input, session.port.to_string(), window, cx);
+        Self::set_input_value(&self.user_input, session.user.clone(), window, cx);
+        Self::set_input_value(&self.password_input, session.password.clone(), window, cx);
+        Self::set_input_value(
+            &self.key_path_input,
+            session.private_key_path.clone(),
+            window,
+            cx,
+        );
+        Self::set_input_value(
+            &self.key_inline_input,
+            session.private_key_inline.clone(),
+            window,
+            cx,
+        );
+    }
+
+    pub(crate) fn open_new_ssh_dialog(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        self.reset_ssh_form(window, cx);
+        self.show_ssh_dialog(window, cx);
+    }
+
+    pub(crate) fn edit_saved_session(
+        &mut self,
+        session_id: String,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let Some(session) = self.config.get(&session_id).cloned() else {
+            self.status = "saved session not found".into();
+            cx.notify();
+            return;
+        };
+        self.load_session_into_form(&session, window, cx);
+        self.show_ssh_dialog(window, cx);
+    }
+
+    pub(crate) fn terminal_cell_width(&self) -> f32 {
+        (self.terminal_font_size * 0.646).max(6.0)
+    }
+
+    pub(crate) fn terminal_line_height(&self) -> f32 {
+        (self.terminal_font_size * 1.385).max(self.terminal_font_size + 2.0)
+    }
+
+    pub(crate) fn change_terminal_font_size(&mut self, delta: f32, cx: &mut Context<Self>) {
+        self.terminal_font_size = (self.terminal_font_size + delta).clamp(10.0, 24.0);
+        self.config.set_terminal_font_size(self.terminal_font_size);
+        if let Err(err) = self.config.save() {
+            tracing::warn!("failed to save terminal font size: {err:#}");
+        }
+        self.status = format!("terminal font size: {:.0}px", self.terminal_font_size).into();
+        cx.notify();
+    }
+
+    pub(crate) fn change_ui_font_size(&mut self, delta: f32, cx: &mut Context<Self>) {
+        self.ui_font_size = (self.ui_font_size + delta).clamp(8.0, 24.0);
+        self.config.set_ui_font_size(self.ui_font_size);
+        if let Err(err) = self.config.save() {
+            tracing::warn!("failed to save UI font size: {err:#}");
+        }
+        Theme::global_mut(cx).font_size = px(self.ui_font_size);
+        self.status = format!("UI font size: {:.0}px", self.ui_font_size).into();
+        cx.notify();
+    }
+
+    pub(crate) fn change_ui_font_family(
+        &mut self,
+        family: &str,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.ui_font_family = family.into();
+        self.config.set_ui_font_family(family);
+        if let Err(err) = self.config.save() {
+            tracing::warn!("failed to save UI font family: {err:#}");
+        }
+        crate::theme::set_theme_font_names(Theme::global_mut(cx), &self.ui_font_family);
+        cx.notify();
+        window.refresh();
+    }
+
+    pub(crate) fn change_terminal_font_family(&mut self, family: &str, cx: &mut Context<Self>) {
+        self.terminal_font_family = family.into();
+        self.config.set_terminal_font_family(family);
+        if let Err(err) = self.config.save() {
+            tracing::warn!("failed to save terminal font family: {err:#}");
+        }
+        cx.notify();
+    }
+
+    pub(crate) fn reset_layout(&mut self, _window: &mut Window, cx: &mut Context<Self>) {
+        self.config.set_layout_state(None, None, None);
+        let _ = self.config.save();
+
+        self.workspace_panels = cx.new(|_| gpui_component::resizable::ResizableState::default());
+        self.body_panels = cx.new(|_| gpui_component::resizable::ResizableState::default());
+
+        self.status = t!("reset_layout_success").into();
+        cx.notify();
+    }
+
+    pub(crate) fn set_ssh_auth_method(&mut self, method: AuthMethod, cx: &mut Context<Self>) {
+        self.ssh_auth_method = method;
+        cx.notify();
+    }
+
+    pub(crate) fn connect_saved_session(&mut self, session_id: String, cx: &mut Context<Self>) {
+        let Some(session) = self.config.get(&session_id).cloned() else {
+            self.status = "saved session not found".into();
+            cx.notify();
+            return;
+        };
+        self.open_ssh_session(session, cx);
+    }
+
+    pub(crate) fn selector_entries(&self) -> Vec<SelectorEntry> {
+        let mut entries = vec![SelectorEntry::Local, SelectorEntry::NewSsh];
+        entries.extend(
+            self.config
+                .sessions()
+                .iter()
+                .map(|session| SelectorEntry::Saved(session.id.clone())),
+        );
+        entries
+    }
+
+    pub(crate) fn default_selector_index(&self) -> usize {
+        if self.config.sessions().is_empty() {
+            0
+        } else {
+            2
+        }
+    }
+
+    pub(crate) fn move_selector_selection(&mut self, delta: i32, cx: &mut Context<Self>) {
+        let entries = self.selector_entries();
+        if entries.is_empty() {
+            return;
+        }
+        let current = self.selector_selection.min(entries.len().saturating_sub(1)) as i32;
+        let next = (current + delta).clamp(0, entries.len() as i32 - 1) as usize;
+        if next != self.selector_selection {
+            self.selector_selection = next;
+            if next >= 2 {
+                self.selector_scroll_handle.scroll_to_item(next - 2);
+            }
+            cx.notify();
+        }
+    }
+
+    pub(crate) fn activate_selector_selection(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let entries = self.selector_entries();
+        let Some(entry) = entries.get(self.selector_selection).cloned() else {
+            return;
+        };
+
+        match entry {
+            SelectorEntry::Local => {
+                self.open_local(cx);
+                window.close_dialog(cx);
+            }
+            SelectorEntry::NewSsh => {
+                window.close_dialog(cx);
+                self.open_new_ssh_dialog(window, cx);
+            }
+            SelectorEntry::Saved(session_id) => {
+                self.connect_saved_session(session_id, cx);
+                window.close_dialog(cx);
+            }
+        }
+    }
+
+    pub(crate) fn on_selector_key_down(
+        &mut self,
+        event: &KeyDownEvent,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let key = event.keystroke.key.to_ascii_lowercase();
+        match key.as_str() {
+            "up" | "arrowup" => {
+                self.move_selector_selection(-1, cx);
+                window.prevent_default();
+                cx.stop_propagation();
+            }
+            "down" | "arrowdown" => {
+                self.move_selector_selection(1, cx);
+                window.prevent_default();
+                cx.stop_propagation();
+            }
+            "enter" | "return" => {
+                self.activate_selector_selection(window, cx);
+                window.prevent_default();
+                cx.stop_propagation();
+            }
+            _ => {}
+        }
+    }
+
+    pub(crate) fn open_ssh_session(&mut self, session: Session, cx: &mut Context<Self>) {
+        let id = Uuid::new_v4().to_string();
+        let backend = ssh_terminal::spawn_ssh_terminal(
+            self.runtime.handle(),
+            id.clone(),
+            session.clone(),
+            DEFAULT_COLS,
+            DEFAULT_ROWS,
+            self.events_tx.clone(),
+        );
+        self.tabs.push(TerminalTab::new_ssh(
+            id.clone(),
+            &session,
+            backend,
+            self.events_tx.clone(),
+        ));
+        self.active_tab = Some(id.clone());
+        self.tabs_scroll_handle.scroll_to_item(self.tabs.len() - 1);
+        if let Some(session_id) = self.active_session_id() {
+            if let Some(index) = self.config.sessions().iter().position(|s| s.id == session_id) {
+                self.saved_scroll_handle.scroll_to_item(index);
+            }
+        }
+        cx.notify();
+        let sftp_handle = sftp::spawn_sftp(
+            self.runtime.handle(),
+            id.clone(),
+            session,
+            self.events_tx.clone(),
+        );
+        self.sftp_handles.insert(id.clone(), sftp_handle);
+        self.active_tab = Some(id.clone());
+        self.pending_sftp_path_sync = Some("/".into());
+        self.connection_progress = Some(ConnectionProgress {
+            tab_id: id,
+            title: t!("connecting").into(),
+            lines: vec![t!("starting_connection").into()],
+            failed: false,
+        });
+        self.status = "ssh tab opened".into();
+        cx.notify();
+    }
+
+    pub(crate) fn remove_saved_session(&mut self, session_id: String, cx: &mut Context<Self>) {
+        self.config.remove(&session_id);
+        if let Err(err) = self.config.save() {
+            tracing::warn!("failed to save config: {err:#}");
+        }
+        self.status = "session removed".into();
+        cx.notify();
+    }
+
+    pub(crate) fn retry_connection_progress(&mut self, cx: &mut Context<Self>) {
+        let Some(progress) = self.connection_progress.clone() else {
+            return;
+        };
+        let Some(ix) = self.tabs.iter().position(|tab| tab.id == progress.tab_id) else {
+            self.connection_progress = None;
+            cx.notify();
+            return;
+        };
+        let Some(session) = self.tabs[ix].session.clone() else {
+            self.connection_progress = None;
+            cx.notify();
+            return;
+        };
+
+        self.tabs[ix].backend.send(BackendCommand::Close);
+        if let Some(handle) = self.sftp_handles.remove(&progress.tab_id) {
+            handle.close();
+        }
+        self.tabs.remove(ix);
+        if self.active_tab.as_deref() == Some(progress.tab_id.as_str()) {
+            self.active_tab = self
+                .tabs
+                .get(ix)
+                .or_else(|| self.tabs.get(ix.saturating_sub(1)))
+                .map(|tab| tab.id.clone());
+        }
+        self.connection_progress = None;
+        self.open_ssh_session(session, cx);
+    }
+
+    pub(crate) fn cancel_connection_progress(&mut self, cx: &mut Context<Self>) {
+        let Some(progress) = self.connection_progress.clone() else {
+            return;
+        };
+        self.connection_progress = None;
+        self.close_tab(progress.tab_id, cx);
+    }
+
+    pub(crate) fn activate_tab(&mut self, id: String, window: &mut Window, cx: &mut Context<Self>) {
+        if let Some(path) = self
+            .tabs
+            .iter()
+            .find(|tab| tab.id == id)
+            .and_then(|tab| tab.sftp.as_ref())
+            .map(|sftp| sftp.current_path.clone())
+        {
+            self.pending_sftp_path_sync = Some(path);
+        }
+        self.active_tab = Some(id.clone());
+        self.cpu_history.clear();
+        self.net_rx_history.clear();
+        self.net_tx_history.clear();
+        if let Some(index) = self.tabs.iter().position(|t| t.id == id) {
+            self.tabs_scroll_handle.scroll_to_item(index);
+        }
+        if self.tabs.iter().any(|t| t.id == id) {
+            if let Some(session_id) = self.active_session_id() {
+                if let Some(index) = self.config.sessions().iter().position(|s| s.id == session_id) {
+                    self.saved_scroll_handle.scroll_to_item(index);
+                }
+            }
+        }
+        self.remote_sample_in_flight = false;
+        self.request_active_system_snapshot();
+        self.focus_handle.focus(window, cx);
+        cx.notify();
+    }
+
+    pub(crate) fn close_tab(&mut self, id: String, cx: &mut Context<Self>) {
+        if let Some(ix) = self.tabs.iter().position(|tab| tab.id == id) {
+            let was_active = self.active_tab.as_deref() == Some(id.as_str());
+            self.tabs[ix].backend.send(BackendCommand::Close);
+            if let Some(handle) = self.sftp_handles.remove(&id) {
+                handle.close();
+            }
+            self.tabs.remove(ix);
+            if was_active
+                || self
+                    .active_tab
+                    .as_ref()
+                    .is_some_and(|active_id| !self.tabs.iter().any(|tab| &tab.id == active_id))
+            {
+                self.active_tab = self
+                    .tabs
+                    .get(ix)
+                    .or_else(|| self.tabs.get(ix.saturating_sub(1)))
+                    .map(|tab| tab.id.clone());
+                self.cpu_history.clear();
+                self.net_rx_history.clear();
+                self.net_tx_history.clear();
+                self.remote_sample_in_flight = false;
+                self.request_active_system_snapshot();
+            }
+            cx.notify();
+        }
+    }
+
+    pub(crate) fn focus_terminal(
+        &mut self,
+        event: &MouseDownEvent,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.focus_handle.focus(window, cx);
+        if event.button == MouseButton::Left {
+            self.begin_terminal_selection(event, cx);
+        }
+        cx.notify();
+    }
+
+    pub(crate) fn active_snapshot(&self) -> Option<RenderSnapshot> {
+        self.active_tab
+            .as_ref()
+            .and_then(|id| self.tabs.iter().find(|t| &t.id == id))
+            .map(TerminalTab::render_snapshot)
+    }
+
+    pub(crate) fn active_kind(&self) -> Option<TabKind> {
+        self.active_tab
+            .as_ref()
+            .and_then(|id| self.tabs.iter().find(|t| &t.id == id))
+            .map(|tab| tab.kind)
+    }
+
+    pub(crate) fn active_title(&self) -> String {
+        self.active_tab
+            .as_ref()
+            .and_then(|id| self.tabs.iter().find(|t| &t.id == id))
+            .map(|t| t.title.clone())
+            .unwrap_or_else(|| t!("idle_no_session").into())
+    }
+
+    pub(crate) fn active_ssh_session(&self) -> Option<(String, Session)> {
+        let active_id = self.active_tab.as_ref()?;
+        let tab = self.tabs.iter().find(|tab| &tab.id == active_id)?;
+        if !tab.connected {
+            return None;
+        }
+        Some((tab.id.clone(), tab.session.clone()?))
+    }
+
+    pub(crate) fn active_session_id(&self) -> Option<&str> {
+        self.active_tab
+            .as_ref()
+            .and_then(|id| self.tabs.iter().find(|tab| &tab.id == id))
+            .and_then(|tab| tab.session.as_ref())
+            .map(|session| session.id.as_str())
+    }
+
+    pub(crate) fn session_detail(&self, session: &Session) -> String {
+        format!("{}@{}:{}", session.user, session.host, session.port)
+    }
+
+    pub(crate) fn sync_terminal_size(&mut self, window: &Window, cx: &App) {
+        let viewport = window.viewport_size();
+        let sidebar_width = self
+            .workspace_panels
+            .read(cx)
+            .sizes()
+            .first()
+            .map(|size| size.as_f32())
+            .unwrap_or(SIDEBAR_WIDTH);
+        let terminal_height = self
+            .body_panels
+            .read(cx)
+            .sizes()
+            .first()
+            .map(|size| size.as_f32())
+            .unwrap_or(viewport.height.as_f32() - TAB_BAR_HEIGHT - 248.0);
+        let width = (viewport.width.as_f32() - sidebar_width - TERMINAL_PADDING_X - 8.0)
+            .max(self.terminal_cell_width());
+        let height = (terminal_height - TERMINAL_PADDING_Y).max(self.terminal_line_height());
+        let cols = (width / self.terminal_cell_width()).floor().max(1.0) as u16;
+        let rows = (height / self.terminal_line_height()).floor().max(1.0) as u16;
+
+        for tab in &mut self.tabs {
+            tab.resize(cols, rows);
+        }
+    }
+}

src/sftp.rs

@@ -1314,6 +1314,7 @@ async fn upload_paths_impl(
         }
     }
 
+
     // Create directories sequentially first
     for dir in dirs_to_create {
         create_remote_dir_all(sftp, &dir).await?;

src/sftp_ops.rs

@@ -0,0 +1,333 @@
+use gpui::{Context, PathPromptOptions, Pixels, Point, Window};
+
+use crate::{
+    Ashell, SftpContextMenuState,
+    sftp::{RemoteEntry, SftpHandle},
+    terminal,
+};
+
+pub(crate) fn is_editable_text_file(filename: &str) -> bool {
+    let lower = filename.to_lowercase();
+    let ext = std::path::Path::new(&lower).extension().and_then(|s| s.to_str()).unwrap_or("");
+    let known_exts = ["txt", "conf", "json", "yaml", "yml", "xml", "ini", "sh", "py", "rs", "js", "ts", "html", "css", "md", "toml", "csv", "log", "cfg"];
+    if known_exts.contains(&ext) {
+        return true;
+    }
+    let known_names = ["dockerfile", "makefile", ".gitignore", ".env"];
+    if known_names.contains(&lower.as_str()) {
+        return true;
+    }
+    false
+}
+
+impl Ashell {
+    pub(crate) fn active_sftp(&self) -> Option<&terminal::SftpUiState> {
+        self.active_tab
+            .as_ref()
+            .and_then(|id| self.tabs.iter().find(|tab| &tab.id == id))
+            .and_then(|tab| tab.sftp.as_ref())
+    }
+
+    pub(crate) fn active_sftp_mut(&mut self) -> Option<&mut terminal::SftpUiState> {
+        let active_id = self.active_tab.clone()?;
+        self.tabs
+            .iter_mut()
+            .find(|tab| tab.id == active_id)
+            .and_then(|tab| tab.sftp.as_mut())
+    }
+
+    pub(crate) fn active_sftp_handle(&self) -> Option<&SftpHandle> {
+        self.active_tab
+            .as_ref()
+            .and_then(|id| self.sftp_handles.get(id))
+    }
+
+    pub(crate) fn navigate_sftp(&mut self, path: String, cx: &mut Context<Self>) {
+        if let Some(handle) = self.active_sftp_handle() {
+            handle.list_dir(path.clone());
+            if let Some(sftp) = self.active_sftp_mut() {
+                sftp.current_path = path;
+                self.pending_sftp_path_sync = Some(sftp.current_path.clone());
+            }
+            cx.notify();
+        }
+    }
+
+    pub(crate) fn select_sftp_entry(&mut self, entry: RemoteEntry, cx: &mut Context<Self>) {
+        if entry.is_dir {
+            self.navigate_sftp(entry.full_path, cx);
+            return;
+        }
+        self.mark_sftp_entry_selected(&entry.full_path, cx);
+        if let Some(sftp) = self.active_sftp_mut() {
+            if !sftp.selected_entries.remove(&entry.full_path) {
+                sftp.selected_entries.insert(entry.full_path);
+            }
+        }
+    }
+
+    pub(crate) fn mark_sftp_entry_selected(&mut self, path: &str, cx: &mut Context<Self>) {
+        if let Some(sftp) = self.active_sftp_mut() {
+            sftp.selected_path = Some(path.to_string());
+        }
+        cx.notify();
+    }
+
+    pub(crate) fn sftp_parent_path(path: &str) -> String {
+        if path == "/" {
+            return "/".to_string();
+        }
+        path.trim_end_matches('/')
+            .rsplit_once('/')
+            .map(|(parent, _)| {
+                if parent.is_empty() {
+                    "/".to_string()
+                } else {
+                    parent.to_string()
+                }
+            })
+            .unwrap_or_else(|| "/".to_string())
+    }
+
+    pub(crate) fn refresh_sftp(&mut self, cx: &mut Context<Self>) {
+        if let Some(path) = self.active_sftp().map(|sftp| sftp.current_path.clone()) {
+            self.navigate_sftp(path, cx);
+        }
+    }
+
+    pub(crate) fn sync_sftp_path_input(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let Some(path) = self.pending_sftp_path_sync.take() else {
+            return;
+        };
+        self.sftp_path_input.update(cx, |state, cx| {
+            state.set_value(path, window, cx);
+        });
+    }
+
+    pub(crate) fn open_sftp_context_menu(
+        &mut self,
+        remote_path: String,
+        is_dir: bool,
+        position: Point<Pixels>,
+        cx: &mut Context<Self>,
+    ) {
+        self.sftp_context_menu = Some(SftpContextMenuState {
+            remote_path,
+            is_dir,
+            position,
+        });
+        cx.notify();
+    }
+
+    pub(crate) fn dismiss_sftp_context_menu(&mut self, cx: &mut Context<Self>) {
+        if self.sftp_context_menu.take().is_some() {
+            cx.notify();
+        }
+    }
+
+    pub(crate) fn trigger_sftp_context_download(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let Some(menu) = self.sftp_context_menu.take() else {
+            return;
+        };
+        self.download_sftp_entry(menu.remote_path, window, cx);
+        cx.notify();
+    }
+
+    pub(crate) fn trigger_sftp_context_edit(&mut self, cx: &mut Context<Self>) {
+        let Some(menu) = self.sftp_context_menu.take() else {
+            return;
+        };
+        if let Some(id) = self.active_tab.clone() {
+            if let Some(handle) = self.sftp_handles.get(&id) {
+                handle.edit_file(menu.remote_path);
+            }
+        }
+        cx.notify();
+    }
+
+    pub(crate) fn download_sftp_entry(
+        &mut self,
+        remote_path: String,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let Some(handle) = self.active_sftp_handle().cloned() else {
+            return;
+        };
+        let path_prompt = cx.prompt_for_paths(PathPromptOptions {
+            files: false,
+            directories: true,
+            multiple: false,
+            prompt: Some("Select Download Folder".into()),
+        });
+        cx.spawn_in(window, async move |this, cx| {
+            match path_prompt.await {
+                Ok(Ok(Some(mut paths))) => {
+                    if let Some(folder) = paths.pop() {
+                        handle.download(remote_path, folder.to_string_lossy().to_string());
+                    }
+                }
+                Ok(Err(err)) => {
+                    this.update(cx, |this, cx| {
+                        this.status = format!("download picker failed: {err}").into();
+                        cx.notify();
+                    })?;
+                }
+                _ => {}
+            }
+            Ok::<(), anyhow::Error>(())
+        })
+        .detach();
+    }
+
+    pub(crate) fn upload_sftp_files(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let Some(handle) = self.active_sftp_handle().cloned() else {
+            return;
+        };
+        let remote_dir = self
+            .active_sftp()
+            .map(|sftp| sftp.current_path.clone())
+            .unwrap_or_else(|| "/".into());
+        let path_prompt = cx.prompt_for_paths(PathPromptOptions {
+            files: true,
+            directories: false,
+            multiple: false,
+            prompt: Some("Select File to Upload".into()),
+        });
+        cx.spawn_in(window, async move |this, cx| {
+            match path_prompt.await {
+                Ok(Ok(Some(mut paths))) => {
+                    if let Some(file) = paths.pop() {
+                        handle.upload_paths(vec![file.to_string_lossy().to_string()], remote_dir);
+                    }
+                }
+                Ok(Err(err)) => {
+                    this.update(cx, |this, cx| {
+                        this.status = format!("upload picker failed: {err}").into();
+                        cx.notify();
+                    })?;
+                }
+                _ => {}
+            }
+            Ok::<(), anyhow::Error>(())
+        })
+        .detach();
+    }
+
+    pub(crate) fn upload_sftp_folder(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let Some(handle) = self.active_sftp_handle().cloned() else {
+            return;
+        };
+        let remote_dir = self
+            .active_sftp()
+            .map(|sftp| sftp.current_path.clone())
+            .unwrap_or_else(|| "/".into());
+        let path_prompt = cx.prompt_for_paths(PathPromptOptions {
+            files: false,
+            directories: true,
+            multiple: false,
+            prompt: Some("Select Folder to Upload".into()),
+        });
+        cx.spawn_in(window, async move |this, cx| {
+            match path_prompt.await {
+                Ok(Ok(Some(mut paths))) => {
+                    if let Some(folder) = paths.pop() {
+                        handle.upload_paths(vec![folder.to_string_lossy().to_string()], remote_dir);
+                    }
+                }
+                Ok(Err(err)) => {
+                    this.update(cx, |this, cx| {
+                        this.status = format!("upload picker failed: {err}").into();
+                        cx.notify();
+                    })?;
+                }
+                _ => {}
+            }
+            Ok::<(), anyhow::Error>(())
+        })
+        .detach();
+    }
+
+    pub(crate) fn toggle_sftp_entry(&mut self, path: String, checked: bool, cx: &mut Context<Self>) {
+        if let Some(sftp) = self.active_sftp_mut() {
+            if checked {
+                sftp.selected_entries.insert(path);
+            } else {
+                sftp.selected_entries.remove(&path);
+            }
+            cx.notify();
+        }
+    }
+
+    pub(crate) fn toggle_all_sftp_entries(&mut self, checked: bool, cx: &mut Context<Self>) {
+        if let Some(sftp) = self.active_sftp_mut() {
+            if checked {
+                let paths: Vec<String> = sftp.entries.iter().map(|e| e.full_path.clone()).collect();
+                for path in paths {
+                    sftp.selected_entries.insert(path);
+                }
+            } else {
+                sftp.selected_entries.clear();
+            }
+            cx.notify();
+        }
+    }
+
+    pub(crate) fn download_selected_sftp_entries(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let Some(sftp) = self.active_sftp() else {
+            return;
+        };
+        let selected: Vec<String> = sftp.selected_entries.iter().cloned().collect();
+        if selected.is_empty() {
+            return;
+        }
+
+        let Some(handle) = self.active_sftp_handle().cloned() else {
+            return;
+        };
+
+        let path_prompt = cx.prompt_for_paths(PathPromptOptions {
+            files: false,
+            directories: true,
+            multiple: false,
+            prompt: Some("Select Download Folder".into()),
+        });
+
+        cx.spawn_in(window, async move |this, cx| {
+            if let Ok(Ok(Some(mut paths))) = path_prompt.await {
+                if let Some(folder) = paths.pop() {
+                    let local_dir = folder.to_string_lossy().to_string();
+                    for remote in selected {
+                        let _ = handle.commands.send(crate::sftp::SftpCommand::Download {
+                            remote,
+                            local_dir: local_dir.clone(),
+                        });
+                    }
+
+                    let _ = this.update(cx, |this, cx| {
+                        if let Some(sftp_mut) = this.active_sftp_mut() {
+                            sftp_mut.selected_entries.clear();
+                        }
+                        cx.notify();
+                    });
+                }
+            }
+            Ok::<(), anyhow::Error>(())
+        })
+        .detach();
+    }
+
+    pub(crate) fn upload_sftp_files_batch(&mut self, paths: Vec<String>, _cx: &mut Context<Self>) {
+        if paths.is_empty() {
+            return;
+        }
+        if let Some(sftp) = self.active_sftp() {
+            if let Some(handle) = self.active_sftp_handle() {
+                let _ = handle.commands.send(crate::sftp::SftpCommand::UploadPaths {
+                    locals: paths,
+                    remote_dir: sftp.current_path.clone(),
+                });
+            }
+        }
+    }
+}

src/ssh_terminal.rs

@@ -365,7 +365,7 @@ EOF
   echo "SWAP_USED=$(( ${swap_total:-0} - ${swap_free:-0} ))"
   echo "NET_RX=$(( ${net_rx_2:-0} - ${net_rx_1:-0} ))"
   echo "NET_TX=$(( ${net_tx_2:-0} - ${net_tx_1:-0} ))"
-  df -kP 2>/dev/null | awk "NR > 1 { printf \"DISK=%s\t%s\t%s\n\", \$6, \$4 * 1024, \$2 * 1024 }" | head -n 4
+  df -kP 2>/dev/null | awk "NR > 1 && \$1 !~ /^(tmpfs|devtmpfs|ramfs|overlay|aufs)\$/ { printf \"DISK=%s\t%s\t%s\n\", \$6, \$4 * 1024, \$2 * 1024 }" | head -n 6
   exit 0
 fi
 
@@ -404,7 +404,7 @@ EOF
   echo "SWAP_USED=${swap_used:-0}"
   echo "NET_RX=$(( ${net_rx_2:-0} - ${net_rx_1:-0} ))"
   echo "NET_TX=$(( ${net_tx_2:-0} - ${net_tx_1:-0} ))"
-  df -kP 2>/dev/null | awk "NR > 1 { printf \"DISK=%s\t%s\t%s\n\", \$6, \$4 * 1024, \$2 * 1024 }" | head -n 4
+  df -kP 2>/dev/null | awk "NR > 1 && \$1 !~ /^(devfs|tmpfs|devtmpfs|ramfs|overlay|aufs)\$/ { printf \"DISK=%s\t%s\t%s\n\", \$6, \$4 * 1024, \$2 * 1024 }" | head -n 6
   exit 0
 fi
 

src/system.rs

@@ -1,11 +1,20 @@
 use std::{
     collections::BTreeMap,
+    ffi::OsStr,
     time::{Duration, Instant},
 };
 
 use anyhow::{Result, anyhow};
 use sysinfo::{Disks, Networks, System};
 
+/// Known virtual/ram filesystems to exclude from disk monitoring.
+fn is_real_filesystem(fs: &OsStr) -> bool {
+    !matches!(
+        fs.to_str(),
+        Some("tmpfs" | "devtmpfs" | "ramfs" | "overlay" | "aufs")
+    )
+}
+
 #[derive(Debug, Clone, Default)]
 pub struct DiskSample {
     pub mount: String,
@@ -22,7 +31,10 @@ pub struct SystemSnapshot {
     pub swap_detail: String,
     pub net_rx: String,
     pub net_tx: String,
+    pub net_rx_rate: u64,
+    pub net_tx_rate: u64,
     pub disks: Vec<DiskSample>,
+    pub total_swap: u64,
 }
 
 pub struct SystemSampler {
@@ -82,17 +94,25 @@ impl SystemSampler {
         self.last_tx_total = tx_total;
         self.last_instant = now;
 
-        let disks = self
+        let mut disks: Vec<DiskSample> = self
             .disks
             .iter()
-            .filter(|disk| disk.total_space() > 0)
-            .take(4)
+            .filter(|disk| disk.total_space() > 0 && is_real_filesystem(disk.file_system()))
             .map(|disk| DiskSample {
                 mount: disk.mount_point().to_string_lossy().to_string(),
                 available_bytes: disk.available_space(),
                 total_bytes: disk.total_space(),
             })
             .collect();
+        disks.sort_by(|a, b| {
+            if a.mount == "/" {
+                return std::cmp::Ordering::Less;
+            }
+            if b.mount == "/" {
+                return std::cmp::Ordering::Greater;
+            }
+            a.mount.cmp(&b.mount)
+        });
 
         SystemSnapshot {
             cpu_percent,
@@ -102,7 +122,10 @@ impl SystemSampler {
             swap_detail: format!("{}/{}", format_bytes(swap_used), format_bytes(swap_total)),
             net_rx: format!("{}/s", format_bytes(rx_rate)),
             net_tx: format!("{}/s", format_bytes(tx_rate)),
+            net_rx_rate: rx_rate,
+            net_tx_rate: tx_rate,
             disks,
+            total_swap: swap_total,
         }
     }
 }
@@ -176,6 +199,20 @@ pub fn remote_snapshot_from_kv(raw: &str) -> Result<SystemSnapshot> {
     let rx_rate = parse_u64(&kv, "NET_RX");
     let tx_rate = parse_u64(&kv, "NET_TX");
 
+    // Safety filter: exclude entries with zero/negligible total size
+    // (catches any virtual fs lines that slipped past the script filter)
+    disks.retain(|d| d.total_bytes >= 1024 * 1024);
+
+    disks.sort_by(|a, b| {
+        if a.mount == "/" {
+            return std::cmp::Ordering::Less;
+        }
+        if b.mount == "/" {
+            return std::cmp::Ordering::Greater;
+        }
+        a.mount.cmp(&b.mount)
+    });
+
     Ok(SystemSnapshot {
         cpu_percent: cpu_percent.clamp(0.0, 1.0),
         mem_percent: ratio(mem_used, mem_total),
@@ -184,7 +221,10 @@ pub fn remote_snapshot_from_kv(raw: &str) -> Result<SystemSnapshot> {
         swap_detail: format!("{}/{}", format_bytes(swap_used), format_bytes(swap_total)),
         net_rx: format!("{}/s", format_bytes(rx_rate)),
         net_tx: format!("{}/s", format_bytes(tx_rate)),
+        net_rx_rate: rx_rate,
+        net_tx_rate: tx_rate,
         disks,
+        total_swap: swap_total,
     })
 }
 

src/terminal_input.rs

@@ -0,0 +1,347 @@
+use std::ops::Range;
+
+use alacritty_terminal::index::Side;
+use alacritty_terminal::selection::SelectionType;
+use gpui::{
+    ClipboardItem, Context, KeyDownEvent, MouseButton, MouseDownEvent, MouseMoveEvent,
+    MouseUpEvent, Pixels, Point, ScrollDelta, ScrollWheelEvent, Window, px,
+};
+
+use crate::{
+    Ashell,
+    terminal::{BackendCommand, encode_key},
+    TerminalBacktabKey, TerminalTabKey,
+};
+
+impl Ashell {
+    pub(crate) fn on_terminal_key_down(
+        &mut self,
+        event: &KeyDownEvent,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        if event.keystroke.modifiers.secondary() && event.keystroke.key == "," {
+            self.show_settings_dialog(window, cx);
+            window.prevent_default();
+            cx.stop_propagation();
+            return;
+        }
+        if event.keystroke.modifiers.shift
+            && event.keystroke.modifiers.secondary()
+            && event.keystroke.key == "o"
+        {
+            self.show_selector_dialog(window, cx);
+            window.prevent_default();
+            cx.stop_propagation();
+            return;
+        }
+        if event.keystroke.modifiers.secondary() && event.keystroke.key.eq_ignore_ascii_case("c") {
+            if let Some(text) = self.active_terminal_selection_text() {
+                cx.write_to_clipboard(ClipboardItem::new_string(text));
+                window.prevent_default();
+                cx.stop_propagation();
+                return;
+            }
+        }
+        if event.keystroke.modifiers.secondary() && event.keystroke.key.eq_ignore_ascii_case("v") {
+            if let Some(clipboard) = cx.read_from_clipboard() {
+                if let Some(text) = clipboard.text() {
+                    self.paste_into_terminal(&text, window, cx);
+                    return;
+                }
+            }
+        }
+
+        if event.prefer_character_input {
+            if let Some(text) = event.keystroke.key_char.as_deref() {
+                if !text.is_empty()
+                    && !event.keystroke.modifiers.control
+                    && !event.keystroke.modifiers.function
+                    && !event.keystroke.modifiers.platform
+                {
+                    self.send_terminal_input(text.as_bytes().to_vec(), window, cx);
+                }
+            }
+            return;
+        }
+
+        let Some(active_id) = self.active_tab.clone() else {
+            return;
+        };
+        let Some(tab) = self.tabs.iter_mut().find(|t| t.id == active_id) else {
+            return;
+        };
+
+        if tab.render_snapshot().display_offset > 0 {
+            tab.scroll_to_bottom();
+        }
+        tab.clear_selection();
+
+        if let Some(bytes) = encode_key(&event.keystroke, tab.app_cursor_mode(), false) {
+            tab.backend.send(BackendCommand::Input(bytes));
+            window.prevent_default();
+            cx.stop_propagation();
+            cx.notify();
+        }
+    }
+
+    pub(crate) fn on_terminal_tab_action(
+        &mut self,
+        _: &TerminalTabKey,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.send_terminal_input(vec![b'\t'], window, cx);
+    }
+
+    pub(crate) fn on_terminal_backtab_action(
+        &mut self,
+        _: &TerminalBacktabKey,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.send_terminal_input(b"\x1b[Z".to_vec(), window, cx);
+    }
+
+    fn send_terminal_input(&mut self, bytes: Vec<u8>, window: &mut Window, cx: &mut Context<Self>) {
+        let Some(active_id) = self.active_tab.clone() else {
+            return;
+        };
+        let Some(tab) = self.tabs.iter_mut().find(|t| t.id == active_id) else {
+            return;
+        };
+
+        if tab.render_snapshot().display_offset > 0 {
+            tab.scroll_to_bottom();
+        }
+
+        tab.clear_selection();
+        tab.backend.send(BackendCommand::Input(bytes));
+        window.prevent_default();
+        cx.stop_propagation();
+        cx.notify();
+    }
+
+    fn active_terminal_selection_text(&self) -> Option<String> {
+        let active_id = self.active_tab.as_ref()?;
+        self.tabs
+            .iter()
+            .find(|tab| &tab.id == active_id)
+            .and_then(|tab| tab.selection_text())
+    }
+
+    fn paste_into_terminal(&mut self, text: &str, window: &mut Window, cx: &mut Context<Self>) {
+        let Some(active_id) = self.active_tab.clone() else {
+            return;
+        };
+        let Some(tab) = self.tabs.iter_mut().find(|tab| tab.id == active_id) else {
+            return;
+        };
+
+        if tab.render_snapshot().display_offset > 0 {
+            tab.scroll_to_bottom();
+        }
+        tab.clear_selection();
+        tab.paste_text(text);
+        window.prevent_default();
+        cx.stop_propagation();
+        cx.notify();
+    }
+
+    pub(crate) fn terminal_accepts_text_input(&self) -> bool {
+        self.active_tab.is_some()
+    }
+
+    pub(crate) fn terminal_marked_text_range(&self) -> Option<Range<usize>> {
+        self.terminal_marked_text
+            .as_ref()
+            .map(|text| 0..text.encode_utf16().count())
+    }
+
+    pub(crate) fn set_terminal_marked_text(
+        &mut self,
+        text: String,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.terminal_marked_text = if text.is_empty() { None } else { Some(text) };
+        window.invalidate_character_coordinates();
+        cx.notify();
+    }
+
+    pub(crate) fn clear_terminal_marked_text(
+        &mut self,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        if self.terminal_marked_text.take().is_some() {
+            window.invalidate_character_coordinates();
+            cx.notify();
+        }
+    }
+
+    pub(crate) fn commit_terminal_ime_text(
+        &mut self,
+        text: &str,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let Some(active_id) = self.active_tab.clone() else {
+            return;
+        };
+        let Some(tab) = self.tabs.iter_mut().find(|tab| tab.id == active_id) else {
+            return;
+        };
+
+        if tab.render_snapshot().display_offset > 0 {
+            tab.scroll_to_bottom();
+        }
+        tab.clear_selection();
+        self.terminal_marked_text = None;
+        tab.backend
+            .send(BackendCommand::Input(text.as_bytes().to_vec()));
+        window.invalidate_character_coordinates();
+        cx.notify();
+    }
+
+    pub(crate) fn on_terminal_right_click(
+        &mut self,
+        _event: &MouseDownEvent,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        if !self.config.right_click_copy_paste() {
+            return;
+        }
+
+        let mut handled = false;
+        if let Some(text) = self.active_terminal_selection_text() {
+            if !text.is_empty() {
+                cx.write_to_clipboard(gpui::ClipboardItem::new_string(text));
+
+                let active_id = self.active_tab.clone();
+                if let Some(active_id) = active_id {
+                    if let Some(tab) = self.tabs.iter_mut().find(|tab| tab.id == active_id) {
+                        tab.clear_selection();
+                    }
+                }
+                cx.notify();
+                handled = true;
+            }
+        }
+
+        if !handled {
+            if let Some(clipboard_item) = cx.read_from_clipboard() {
+                if let Some(text) = clipboard_item.text() {
+                    if !text.is_empty() {
+                        self.paste_into_terminal(&text, window, cx);
+                    }
+                }
+            }
+        }
+    }
+
+    pub(crate) fn begin_terminal_selection(&mut self, event: &MouseDownEvent, cx: &mut Context<Self>) {
+        let click_count = event.click_count.max(1);
+        let selection_type = match click_count {
+            1 => SelectionType::Simple,
+            2 => SelectionType::Semantic,
+            3 => SelectionType::Lines,
+            _ => SelectionType::Simple,
+        };
+        let Some((row, col, side)) = self.terminal_grid_point_and_side(event.position) else {
+            return;
+        };
+        let Some(active_id) = self.active_tab.clone() else {
+            return;
+        };
+        if let Some(tab) = self.tabs.iter_mut().find(|tab| tab.id == active_id) {
+            tab.begin_selection(row, col, side, selection_type);
+            self.terminal_selecting = true;
+            cx.notify();
+        }
+    }
+
+    pub(crate) fn on_terminal_mouse_move(
+        &mut self,
+        event: &MouseMoveEvent,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        if !self.terminal_selecting || event.pressed_button != Some(MouseButton::Left) {
+            return;
+        }
+        let Some((row, col, side)) = self.terminal_grid_point_and_side(event.position) else {
+            return;
+        };
+        let Some(active_id) = self.active_tab.clone() else {
+            return;
+        };
+        if let Some(tab) = self.tabs.iter_mut().find(|tab| tab.id == active_id) {
+            tab.update_selection(row, col, side);
+            cx.notify();
+        }
+    }
+
+    pub(crate) fn on_terminal_mouse_up(
+        &mut self,
+        _event: &MouseUpEvent,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.terminal_selecting = false;
+        cx.notify();
+    }
+
+    fn terminal_grid_point_and_side(
+        &self,
+        position: Point<Pixels>,
+    ) -> Option<(usize, usize, Side)> {
+        let bounds = self.terminal_bounds?;
+        if !bounds.contains(&position) {
+            return None;
+        }
+        let local_x = (position.x - bounds.origin.x).max(px(0.));
+        let local_y = (position.y - bounds.origin.y).max(px(0.));
+        let cell_width = px(self.terminal_cell_width());
+        let line_height = px(self.terminal_line_height());
+        let snapshot = self.active_snapshot()?;
+        let max_col = snapshot.cols.saturating_sub(1);
+        let max_row = snapshot.rows.saturating_sub(1);
+        let col = ((local_x / cell_width).floor() as usize).min(max_col);
+        let row = ((local_y / line_height).floor() as usize).min(max_row);
+        let cell_offset_x = px(local_x.as_f32() % cell_width.as_f32());
+        let side = if cell_offset_x >= (cell_width / 2.) {
+            Side::Right
+        } else {
+            Side::Left
+        };
+        Some((row, col, side))
+    }
+
+    pub(crate) fn on_terminal_scroll(
+        &mut self,
+        event: &ScrollWheelEvent,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let delta_lines = match event.delta {
+            ScrollDelta::Lines(point) => point.y.round() as i32,
+            ScrollDelta::Pixels(point) => {
+                (point.y.as_f32() / self.terminal_line_height()).round() as i32
+            }
+        };
+        if delta_lines == 0 {
+            return;
+        }
+        let Some(active_id) = self.active_tab.clone() else {
+            return;
+        };
+        if let Some(tab) = self.tabs.iter_mut().find(|tab| tab.id == active_id) {
+            tab.scroll_history(delta_lines);
+            window.prevent_default();
+            cx.stop_propagation();
+            cx.notify();
+        }
+    }
+}

src/theme.rs

@@ -0,0 +1,210 @@
+use gpui::{Anchor, Context, IntoElement, SharedString, Window, px};
+use gpui_component::{
+    ActiveTheme as _, IconName, Sizable as _, Theme, ThemeMode, ThemeRegistry,
+    button::{Button, ButtonVariants as _},
+    menu::{DropdownMenu as _, PopupMenuItem},
+};
+use rust_i18n::t;
+
+use crate::Ashell;
+
+pub(crate) fn set_theme_font_names(theme: &mut Theme, ui_font_family: &str) {
+    theme.font_family = ui_font_family.into();
+    theme.mono_font_family = ui_font_family.into();
+}
+
+impl Ashell {
+    pub(crate) fn switch_theme_mode(&mut self, mode: ThemeMode, window: &mut Window, cx: &mut Context<Self>) {
+        self.follow_system_theme = false;
+        self.theme_mode = mode;
+        self.apply_theme_preferences(window, cx);
+        self.status = format!("theme mode: {}", cx.theme().mode.name()).into();
+        self.persist_theme_preferences();
+        cx.notify();
+    }
+
+    pub(crate) fn apply_theme(&mut self, name: SharedString, window: &mut Window, cx: &mut Context<Self>) {
+        let Some(theme_config) = ThemeRegistry::global(cx).themes().get(&name).cloned() else {
+            self.status = format!("theme not found: {name}").into();
+            cx.notify();
+            return;
+        };
+
+        if theme_config.mode.is_dark() {
+            self.dark_theme_name = name.clone();
+        } else {
+            self.light_theme_name = name.clone();
+        }
+        self.apply_theme_preferences(window, cx);
+        self.status = format!("theme: {name}").into();
+        self.persist_theme_preferences();
+        window.refresh();
+        cx.notify();
+    }
+
+    pub(crate) fn set_follow_system_theme(
+        &mut self,
+        follow: bool,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.follow_system_theme = follow;
+        if follow {
+            self.status = "theme mode: system".into();
+        } else {
+            self.status = format!("theme mode: {}", cx.theme().mode.name()).into();
+        }
+        self.apply_theme_preferences(window, cx);
+        self.persist_theme_preferences();
+        cx.notify();
+    }
+
+    pub(crate) fn set_display_language(&mut self, locale: &str, window: &mut Window, cx: &mut Context<Self>) {
+        self.config.set_locale(locale);
+        let mut active_locale = locale.to_string();
+        if active_locale == "system" {
+            active_locale = sys_locale::get_locale().unwrap_or_else(|| "en".to_string());
+            if active_locale.starts_with("zh") {
+                active_locale = "zh-CN".to_string();
+            } else {
+                active_locale = "en".to_string();
+            }
+        }
+        rust_i18n::set_locale(&active_locale);
+        gpui_component::set_locale(&active_locale);
+        if let Err(err) = self.config.save() {
+            tracing::warn!("failed to save language preferences: {err:#}");
+        }
+        window.refresh();
+        cx.notify();
+    }
+
+    pub(crate) fn apply_theme_preferences(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let light_theme = ThemeRegistry::global(cx)
+            .themes()
+            .get(&self.light_theme_name)
+            .cloned()
+            .unwrap_or_else(|| ThemeRegistry::global(cx).default_light_theme().clone());
+        let dark_theme = ThemeRegistry::global(cx)
+            .themes()
+            .get(&self.dark_theme_name)
+            .cloned()
+            .unwrap_or_else(|| ThemeRegistry::global(cx).default_dark_theme().clone());
+        let theme = Theme::global_mut(cx);
+        theme.light_theme = light_theme;
+        theme.dark_theme = dark_theme;
+        theme.font_size = px(self.ui_font_size);
+        set_theme_font_names(theme, &self.ui_font_family);
+
+        if self.follow_system_theme {
+            Theme::sync_system_appearance(Some(window), cx);
+        } else {
+            Theme::change(self.theme_mode, Some(window), cx);
+        }
+    }
+
+    pub(crate) fn persist_theme_preferences(&mut self) {
+        let theme_mode_str = match self.theme_mode {
+            ThemeMode::Light => "light",
+            ThemeMode::Dark => "dark",
+        };
+        self.config.set_theme_preferences(
+            self.follow_system_theme,
+            theme_mode_str,
+            self.light_theme_name.to_string(),
+            self.dark_theme_name.to_string(),
+        );
+        if let Err(err) = self.config.save() {
+            tracing::warn!("failed to save theme preferences: {err:#}");
+        }
+    }
+
+    pub(crate) fn theme_dropdown(&self, cx: &mut Context<Self>) -> impl IntoElement {
+        let view = cx.entity();
+        let themes = ThemeRegistry::global(cx)
+            .sorted_themes()
+            .into_iter()
+            .cloned()
+            .collect::<Vec<_>>();
+        let light_themes = themes
+            .iter()
+            .filter(|theme| !theme.mode.is_dark())
+            .map(|theme| theme.name.clone())
+            .collect::<Vec<_>>();
+        let dark_themes = themes
+            .iter()
+            .filter(|theme| theme.mode.is_dark())
+            .map(|theme| theme.name.clone())
+            .collect::<Vec<_>>();
+        let follow_system = self.follow_system_theme;
+        let is_dark_mode = cx.theme().mode.is_dark();
+        let light_theme_name = self.light_theme_name.clone();
+        let dark_theme_name = self.dark_theme_name.clone();
+        let icon = if follow_system {
+            IconName::Sun
+        } else if is_dark_mode {
+            IconName::Moon
+        } else {
+            IconName::Sun
+        };
+
+        Button::new("theme-dropdown")
+            .ghost()
+            .small()
+            .icon(icon)
+            .dropdown_menu_with_anchor(Anchor::BottomRight, move |mut menu, window, _| {
+                menu = menu
+                    .min_w(220.)
+                    .item(
+                        PopupMenuItem::new(t!("follow_system"))
+                            .checked(follow_system)
+                            .on_click(window.listener_for(&view, |this, _, window, cx| {
+                                this.set_follow_system_theme(true, window, cx)
+                            })),
+                    )
+                    .item(
+                        PopupMenuItem::new(t!("use_light_mode"))
+                            .checked(!follow_system && !is_dark_mode)
+                            .on_click(window.listener_for(&view, |this, _, window, cx| {
+                                this.switch_theme_mode(ThemeMode::Light, window, cx)
+                            })),
+                    )
+                    .item(
+                        PopupMenuItem::new(t!("use_dark_mode"))
+                            .checked(!follow_system && is_dark_mode)
+                            .on_click(window.listener_for(&view, |this, _, window, cx| {
+                                this.switch_theme_mode(ThemeMode::Dark, window, cx)
+                            })),
+                    )
+                    .separator()
+                    .label(t!("light_theme").to_string());
+
+                for theme_name in light_themes.clone() {
+                    let checked = theme_name == light_theme_name;
+                    menu = menu.item(
+                        PopupMenuItem::new(theme_name.clone())
+                            .checked(checked)
+                            .on_click(window.listener_for(&view, move |this, _, window, cx| {
+                                this.apply_theme(theme_name.clone(), window, cx)
+                            })),
+                    );
+                }
+
+                menu = menu.separator();
+                menu = menu.label(t!("dark_theme").to_string());
+
+                for theme_name in dark_themes.clone() {
+                    let checked = theme_name == dark_theme_name;
+                    menu = menu.item(
+                        PopupMenuItem::new(theme_name.clone())
+                            .checked(checked)
+                            .on_click(window.listener_for(&view, move |this, _, window, cx| {
+                                this.apply_theme(theme_name.clone(), window, cx)
+                            })),
+                    );
+                }
+
+                menu
+            })
+    }
+}