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.

Cargo.lock

@@ -299,6 +299,8 @@ dependencies = [
  "gpui_platform",
  "image",
  "menu",
+ "notify 6.1.1",
+ "open",
  "portable-pty",
  "rfd",
  "russh",
@@ -1414,6 +1416,15 @@ dependencies = [
  "cfg-if",
 ]
 
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
+dependencies = [
+ "crossbeam-utils",
+]
+
 [[package]]
 name = "crossbeam-deque"
 version = "0.8.6"
@@ -2696,7 +2707,7 @@ dependencies = [
  "lsp-types",
  "markdown",
  "markup5ever_rcdom",
- "notify",
+ "notify 7.0.0",
  "num-traits",
  "once_cell",
  "paste",
@@ -3458,6 +3469,17 @@ dependencies = [
  "serde_core",
 ]
 
+[[package]]
+name = "inotify"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8069d3ec154eb856955c1c0fbffefbf5f3c40a104ec912d4797314c1801abff"
+dependencies = [
+ "bitflags 1.3.2",
+ "inotify-sys",
+ "libc",
+]
+
 [[package]]
 name = "inotify"
 version = "0.10.2"
@@ -3547,6 +3569,25 @@ version = "2.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d98f6fed1fde3f8c21bc40a1abb88dd75e67924f9cffc3ef95607bad8017f8e2"
 
+[[package]]
+name = "is-docker"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "928bae27f42bc99b60d9ac7334e3a21d10ad8f1835a4e12ec3ec0464765ed1b3"
+dependencies = [
+ "once_cell",
+]
+
+[[package]]
+name = "is-wsl"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "173609498df190136aa7dea1a91db051746d339e18476eed5ca40521f02d7aa5"
+dependencies = [
+ "is-docker",
+ "once_cell",
+]
+
 [[package]]
 name = "itertools"
 version = "0.11.0"
@@ -4109,6 +4150,18 @@ dependencies = [
  "simd-adler32",
 ]
 
+[[package]]
+name = "mio"
+version = "0.8.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4a650543ca06a924e8b371db273b2756685faae30f8487da1b56505a8f78b0c"
+dependencies = [
+ "libc",
+ "log",
+ "wasi",
+ "windows-sys 0.48.0",
+]
+
 [[package]]
 name = "mio"
 version = "1.2.1"
@@ -4270,6 +4323,25 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "notify"
+version = "6.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6205bd8bb1e454ad2e27422015fb5e4f2bcc7e08fa8f27058670d208324a4d2d"
+dependencies = [
+ "bitflags 2.12.1",
+ "crossbeam-channel",
+ "filetime",
+ "fsevent-sys",
+ "inotify 0.9.6",
+ "kqueue",
+ "libc",
+ "log",
+ "mio 0.8.11",
+ "walkdir",
+ "windows-sys 0.48.0",
+]
+
 [[package]]
 name = "notify"
 version = "7.0.0"
@@ -4279,11 +4351,11 @@ dependencies = [
  "bitflags 2.12.1",
  "filetime",
  "fsevent-sys",
- "inotify",
+ "inotify 0.10.2",
  "kqueue",
  "libc",
  "log",
- "mio",
+ "mio 1.2.1",
  "notify-types",
  "walkdir",
  "windows-sys 0.52.0",
@@ -4707,6 +4779,17 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"
 
+[[package]]
+name = "open"
+version = "5.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2fbaa89d2ddc8473c78a3adf69eea8cffa28c483b8e02a971ef31527cd0fc92c"
+dependencies = [
+ "is-wsl",
+ "libc",
+ "pathdiff",
+]
+
 [[package]]
 name = "openssl-probe"
 version = "0.2.1"
@@ -4832,6 +4915,12 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "35fb2e5f958ec131621fdd531e9fc186ed768cbe395337403ae56c17a74c68ec"
 
+[[package]]
+name = "pathdiff"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df94ce210e5bc13cb6651479fa48d14f601d9858cfe0467f43ae157023b938d3"
+
 [[package]]
 name = "pathfinder_geometry"
 version = "0.5.1"
@@ -7418,7 +7507,7 @@ checksum = "8fc7f01b389ac15039e4dc9531aa973a135d7a4135281b12d7c1bc79fd57fffe"
 dependencies = [
  "bytes",
  "libc",
- "mio",
+ "mio 1.2.1",
  "pin-project-lite",
  "socket2",
  "tokio-macros",

Cargo.toml

@@ -40,6 +40,8 @@ walkdir = "2"
 zip = { version = "2", default-features = false, features = ["deflate"] }
 image = { version = "0.25.9", default-features = false, features = ["png"] }
 futures = "0.3.32"
+notify = "6.1.1"
+open = "5.1"
 
 [profile.release]
 opt-level = 3

README.en.md

@@ -11,8 +11,8 @@ This project focuses on providing a high-performance and visually appealing shel
 ## 🚀 v0.3 Massive Update!
 
 The brand-new v0.3 introduces comprehensive upgrades to both architecture and user experience:
-- ✨ **Global Real-Time Font Sizing** (Thanks to [@ancion](https://github.com/ancion) for [PR #6](https://github.com/rust-kotlin/ashell/pull/6)): Customize your global UI fonts and terminal rendering fonts independently. Adjust text size with real-time scaling and automatic persistence.
-- ✨ **Concurrent SFTP Transfers**: A dedicated Transfers dialog now supports highly optimized, concurrent file uploads and downloads with precise progress, speed, and ETA calculations.
+- ✨ **Global Real-Time Font Settings** (Thanks to [@ancion](https://github.com/ancion) for [PR #6](https://github.com/rust-kotlin/ashell/pull/6)): Customize your global UI fonts and terminal rendering fonts independently. Adjust text size in real-time with automatic persistence.
+- ✨ **Concurrent SFTP Transfers**: A dedicated Transfers dialog now supports highly optimized, concurrent file uploads and downloads with precise progress display.
 - ✨ **Persistent Workspace State**: Your sidebar width adjustments, terminal themes, font settings, and file visibility preferences are completely restored upon your next launch!
 - ✨ **Intelligent SSH Disconnect/Reconnect**: Greatly enhanced SSH connection resilience. Provides a beautiful and localized overlay for one-click re-connection on unexpected disconnections.
 - ✨ **Hot-Swappable i18n System**: Deeply optimized internationalization. Switch instantly between English and Simplified Chinese without restarting the application.

README.md

@@ -11,8 +11,8 @@
 ## 🚀 v0.3 版本重磅更新！
 
 全新发布的 v0.3 迎来了架构和体验的全面升级：
-- ✨ **全局实时字体设置与无级缩放**（感谢 [@ancion](https://github.com/ancion) 提供的 [PR #6](https://github.com/rust-kotlin/ashell/pull/6)）：支持自定义全局 UI 字体和终端渲染字体，支持实时字号调节缩放并自动记忆。
-- ✨ **SFTP 多任务并发传输队列**：引入全新的独立传输对话框，支持多文件并发上传下载，提供精准的进度条、速率和剩余时间显示。
+- ✨ **全局实时字体设置与字号调节**（感谢 [@ancion](https://github.com/ancion) 提供的 [PR #6](https://github.com/rust-kotlin/ashell/pull/6)）：支持自定义全局 UI 字体和终端渲染字体，支持实时字号调节并自动记忆。
+- ✨ **SFTP 多任务并发传输队列**：引入全新的独立传输对话框，支持多文件并发上传下载，提供精准的进度展示。
 - ✨ **持久化工作区记忆**：您对侧边栏的尺寸拖拽、终端主题、字体、隐藏文件开关等一切设置都会在下次启动时原样恢复！
 - ✨ **智能断线重连与状态感知**：全面增强的 SSH 网络异常处理机制，断线后直接提供美观的覆盖层用于一键重连或关闭。
 - ✨ **多语言热切换增强**：深度优化的 i18n 系统，包含中文与英文在内的所有界面文案现在均支持热切换。

locales/en.yml

@@ -6,12 +6,23 @@ upload_file: "Upload File"
 upload_folder: "Upload Folder"
 hidden: "Hidden"
 download: "Download"
+download_folder: "Download Folder"
 download_count: "Download (%{count})"
 name: "NAME"
 size: "SIZE"
 modified: "MODIFIED"
 new_ssh_connection: "New SSH Connection"
 create_or_edit_ssh_session: "Create or edit an SSH session"
+new_folder: "New Folder"
+create_folder_success: "Created folder: %{name}"
+create_folder_failed: "Failed to create folder: %{err}"
+delete_selected: "Delete"
+confirm_delete: "Confirm Delete"
+confirm_delete_desc: "Are you sure you want to delete the selected %{count} items? This action cannot be undone."
+system_path_warning: "WARNING: You are attempting to delete critical system paths! This may cause system corruption!"
+delete_success: "Successfully deleted %{count} items"
+delete_failed: "Failed to delete: %{err}"
+deleting_paths: "Deleting %{count} items..."
 local_terminal: "Local Terminal"
 open_local_shell_tab: "Open a new local shell tab"
 connect: "Connect"
@@ -57,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"
@@ -94,4 +109,7 @@ session: "Session"
 software_builtin: "Built-in"
 retry: "Retry"
 right_click_copy_paste: "Right-click Copy/Paste"
-copy_paste_hint: "Tip: Regardless of this switch, you can always use %{key} + C/V to copy/paste."
+copy_paste_hint: "Tip: Regardless of this switch, you can always use %{key} + C/V to copy/paste."
+edit_file: "Edit File"
+edit_file_tooltip: "Download to temporary directory, open in default editor, and auto upload on save."
+auto_saved_and_uploaded: "Auto-saved & uploaded: %{base}"

locales/zh-CN.yml

@@ -6,12 +6,25 @@ upload_file: "上传文件"
 upload_folder: "上传文件夹"
 hidden: "显示隐藏文件"
 download: "下载"
+download_folder: "下载文件夹"
 download_count: "下载 (%{count})"
 name: "名称"
 size: "大小"
 modified: "修改时间"
 new_ssh_connection: "新建 SSH 连接"
 create_or_edit_ssh_session: "创建或编辑一个 SSH 会话"
+new_folder: "新建文件夹"
+create_folder_success: "成功创建文件夹: %{name}"
+create_folder_failed: "创建文件夹失败: %{err}"
+delete_selected: "删除"
+confirm_delete: "确认删除"
+confirm_delete_desc: "确定要删除以下选中的 %{count} 个项吗？此操作无法撤销。"
+system_path_warning: "警告：您即将删除系统关键路径！这可能会导致系统损坏！"
+delete_success: "成功删除 %{count} 个项"
+delete_failed: "删除失败: %{err}"
+deleting_paths: "正在删除 %{count} 个项..."
+cancel: "取消"
+confirm: "确认"
 local_terminal: "本地终端"
 open_local_shell_tab: "打开一个新的本地终端页面"
 connect: "连接"
@@ -56,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: "正在连接"
@@ -94,4 +111,7 @@ session: "会话"
 software_builtin: "软件内置"
 retry: "重试"
 right_click_copy_paste: "右键复制/粘贴"
-copy_paste_hint: "提示：不管是否开启此开关，都可以使用 %{key} + C/V 快捷键进行复制和粘贴。"
+copy_paste_hint: "提示：不管是否开启此开关，都可以使用 %{key} + C/V 快捷键进行复制和粘贴。"
+edit_file: "编辑文件"
+edit_file_tooltip: "下载到临时目录，使用默认编辑器打开，并在保存后自动上传。"
+auto_saved_and_uploaded: "已自动保存并上传: %{base}"

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

@@ -125,6 +125,14 @@ pub struct ConfigFile {
     pub body_panels: Option<Vec<f32>>,
     #[serde(default)]
     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 {
@@ -160,6 +168,9 @@ impl ConfigStore {
         if let Some(parent) = path.parent() {
             fs::create_dir_all(parent)
                 .with_context(|| format!("failed to create config dir {}", parent.display()))?;
+            let tmp_dir = parent.join("tmp");
+            let _ = fs::remove_dir_all(&tmp_dir);
+            let _ = fs::create_dir_all(&tmp_dir);
         }
 
         let cache = if path.exists() {
@@ -193,6 +204,10 @@ impl ConfigStore {
         &self.cache.sessions
     }
 
+    pub fn tmp_dir(&self) -> Option<PathBuf> {
+        self.path.parent().map(|p| p.join("tmp"))
+    }
+
     pub fn follow_system_theme(&self) -> bool {
         self.cache.follow_system_theme
     }
@@ -221,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()
@@ -250,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()
     }
@@ -324,6 +348,14 @@ impl ConfigStore {
         self.cache.terminal_font_family = family.to_string();
     }
 
+    pub fn show_hidden_files(&self) -> bool {
+        self.cache.show_hidden_files
+    }
+
+    pub fn set_show_hidden_files(&mut self, val: bool) {
+        self.cache.show_hidden_files = val;
+    }
+
     pub fn get(&self, id: &str) -> Option<&Session> {
         self.cache.sessions.iter().find(|s| s.id == id)
     }

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

@@ -58,6 +58,15 @@ pub enum SftpCommand {
         remote: String,
         local_dir: String,
     },
+    EditFile {
+        remote_path: String,
+    },
+    CreateDir(String),
+    DeletePaths(Vec<String>),
+    UploadEditedFile {
+        local_path: String,
+        remote_path: String,
+    },
     UploadPaths {
         locals: Vec<String>,
         remote_dir: String,
@@ -77,11 +86,17 @@ impl TransferStateFlag {
     pub fn new() -> Self {
         Self(Arc::new(AtomicU8::new(0)))
     }
-    
-    pub fn pause(&self) { self.0.store(1, Ordering::SeqCst); }
-    pub fn resume(&self) { self.0.store(0, Ordering::SeqCst); }
-    pub fn cancel(&self) { self.0.store(2, Ordering::SeqCst); }
-    
+
+    pub fn pause(&self) {
+        self.0.store(1, Ordering::SeqCst);
+    }
+    pub fn resume(&self) {
+        self.0.store(0, Ordering::SeqCst);
+    }
+    pub fn cancel(&self) {
+        self.0.store(2, Ordering::SeqCst);
+    }
+
     pub async fn yield_if_paused(
         &self,
         events: &std::sync::mpsc::Sender<crate::terminal::BackendEvent>,
@@ -161,6 +176,10 @@ impl SftpHandle {
             .send(SftpCommand::UploadPaths { locals, remote_dir });
     }
 
+    pub fn edit_file(&self, remote_path: String) {
+        let _ = self.commands.send(SftpCommand::EditFile { remote_path });
+    }
+
     pub fn close(&self) {
         let _ = self.commands.send(SftpCommand::Close);
     }
@@ -187,7 +206,15 @@ pub fn spawn_sftp(
     let (cmd_tx, cmd_rx) = mpsc::unbounded_channel();
     let cmd_tx_clone = cmd_tx.clone();
     let join = runtime.spawn(async move {
-        if let Err(err) = run_sftp(tab_id.clone(), session, cmd_rx, cmd_tx_clone, events.clone()).await {
+        if let Err(err) = run_sftp(
+            tab_id.clone(),
+            session,
+            cmd_rx,
+            cmd_tx_clone,
+            events.clone(),
+        )
+        .await
+        {
             let _ = events.send(BackendEvent::SftpStatus {
                 tab_id,
                 text: format!("sftp error: {err:#}"),
@@ -229,9 +256,16 @@ async fn run_sftp(
         .canonicalize(".")
         .await
         .unwrap_or_else(|_| "/".to_string());
+    
+    let _ = events.send(BackendEvent::SftpHome {
+        tab_id: tab_id.clone(),
+        home: home.clone(),
+    });
+
     emit_entries(&events, &tab_id, &sftp, &home).await?;
 
-    let mut active_transfers: std::collections::HashMap<String, TransferStateFlag> = std::collections::HashMap::new();
+    let mut active_transfers: std::collections::HashMap<String, TransferStateFlag> =
+        std::collections::HashMap::new();
 
     while let Some(command) = commands.recv().await {
         match command {
@@ -308,16 +342,33 @@ async fn run_sftp(
                 let commands_tx_clone = commands_tx.clone();
 
                 tokio::spawn(async move {
-                    let Ok(channel) = handle_clone.channel_open_session().await else { return };
-                    let Ok(_) = channel.request_subsystem(true, "sftp").await else { return };
-                    let Ok(sftp_session) = SftpSession::new(channel.into_stream()).await else { return };
-                    
+                    let Ok(channel) = handle_clone.channel_open_session().await else {
+                        return;
+                    };
+                    let Ok(_) = channel.request_subsystem(true, "sftp").await else {
+                        return;
+                    };
+                    let Ok(sftp_session) = SftpSession::new(channel.into_stream()).await else {
+                        return;
+                    };
+
                     let _ = events_clone.send(BackendEvent::SftpStatus {
                         tab_id: tab_id_clone.clone(),
                         text: t!("downloading_file", base = base_name(&remote)).to_string(),
                     });
 
-                    match download_path_impl(&handle_clone, &sftp_session, &remote, Path::new(&local_dir), flag, &events_clone, &tab_id_clone, &id).await {
+                    match download_path_impl(
+                        &handle_clone,
+                        &sftp_session,
+                        &remote,
+                        Path::new(&local_dir),
+                        flag,
+                        &events_clone,
+                        &tab_id_clone,
+                        &id,
+                    )
+                    .await
+                    {
                         Ok(summary) => {
                             let _ = events_clone.send(BackendEvent::SftpStatus {
                                 tab_id: tab_id_clone,
@@ -364,7 +415,12 @@ async fn run_sftp(
                     } else if file_count == 0 && folder_count > 0 {
                         t!("n_folders", folders = folder_count).to_string()
                     } else {
-                        t!("n_files_and_folders", files = file_count, folders = folder_count).to_string()
+                        t!(
+                            "n_files_and_folders",
+                            files = file_count,
+                            folders = folder_count
+                        )
+                        .to_string()
                     }
                 };
 
@@ -387,16 +443,32 @@ async fn run_sftp(
                 let commands_tx_clone = commands_tx.clone();
 
                 tokio::spawn(async move {
-                    let Ok(channel) = handle_clone.channel_open_session().await else { return };
-                    let Ok(_) = channel.request_subsystem(true, "sftp").await else { return };
-                    let Ok(sftp_session) = SftpSession::new(channel.into_stream()).await else { return };
-                    
+                    let Ok(channel) = handle_clone.channel_open_session().await else {
+                        return;
+                    };
+                    let Ok(_) = channel.request_subsystem(true, "sftp").await else {
+                        return;
+                    };
+                    let Ok(sftp_session) = SftpSession::new(channel.into_stream()).await else {
+                        return;
+                    };
+
                     let _ = events_clone.send(BackendEvent::SftpStatus {
                         tab_id: tab_id_clone.clone(),
                         text: t!("uploading").to_string(),
                     });
 
-                    match upload_paths_impl(&sftp_session, &locals, &remote_dir, flag, &events_clone, &tab_id_clone, &id).await {
+                    match upload_paths_impl(
+                        &sftp_session,
+                        &locals,
+                        &remote_dir,
+                        flag,
+                        &events_clone,
+                        &tab_id_clone,
+                        &id,
+                    )
+                    .await
+                    {
                         Ok(summary) => {
                             let _ = events_clone.send(BackendEvent::SftpStatus {
                                 tab_id: tab_id_clone.clone(),
@@ -422,6 +494,223 @@ async fn run_sftp(
                     let _ = commands_tx_clone.send(SftpCommand::TransferFinished(id));
                 });
             }
+            SftpCommand::EditFile { remote_path } => {
+                let id = uuid::Uuid::new_v4().to_string();
+                let config = crate::config::ConfigStore::load().unwrap();
+                let tmp_dir = config.tmp_dir().unwrap_or_else(|| PathBuf::from("/tmp"));
+                let base = base_name(&remote_path);
+                let local_path = tmp_dir.join(format!("{}-{}", id, base));
+
+                let handle_clone = handle.clone();
+                let commands_tx_clone = commands_tx.clone();
+                let events_clone = events.clone();
+                let tab_id_clone = tab_id.clone();
+
+                tokio::spawn(async move {
+                    let flag = TransferStateFlag::new();
+                    let Ok(channel) = handle_clone.channel_open_session().await else {
+                        return;
+                    };
+                    let Ok(_) = channel.request_subsystem(true, "sftp").await else {
+                        return;
+                    };
+                    let Ok(sftp_session) = SftpSession::new(channel.into_stream()).await else {
+                        return;
+                    };
+
+                    let _ = events_clone.send(BackendEvent::SftpStatus {
+                        tab_id: tab_id_clone.clone(),
+                        text: t!("downloading_file", base = base).to_string(),
+                    });
+
+                    if let Err(err) = download_file_impl(
+                        &sftp_session,
+                        &remote_path,
+                        &local_path,
+                        &flag,
+                        &events_clone,
+                        &tab_id_clone,
+                        "edit-download",
+                    )
+                    .await
+                    {
+                        let _ = events_clone.send(BackendEvent::SftpStatus {
+                            tab_id: tab_id_clone.clone(),
+                            text: format!("Edit download failed: {err:#}"),
+                        });
+                        return;
+                    }
+
+                    if let Err(err) = open::that(&local_path) {
+                        let _ = events_clone.send(BackendEvent::SftpStatus {
+                            tab_id: tab_id_clone.clone(),
+                            text: format!("Failed to open editor: {err:#}"),
+                        });
+                        return;
+                    }
+
+                    use notify::Watcher;
+                    let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
+                    let mut watcher = match notify::recommended_watcher(
+                        move |res: notify::Result<notify::Event>| {
+                            if let Ok(event) = res {
+                                if event.kind.is_modify() {
+                                    let _ = tx.send(());
+                                }
+                            }
+                        },
+                    ) {
+                        Ok(w) => w,
+                        Err(_) => return,
+                    };
+
+                    if let Err(_) = watcher.watch(&local_path, notify::RecursiveMode::NonRecursive)
+                    {
+                        return;
+                    }
+
+                    while let Some(_) = rx.recv().await {
+                        tokio::time::sleep(std::time::Duration::from_millis(500)).await;
+                        while let Ok(_) = rx.try_recv() {} // drain pending
+
+                        if commands_tx_clone.send(SftpCommand::UploadEditedFile {
+                            local_path: local_path.to_string_lossy().to_string(),
+                            remote_path: remote_path.clone(),
+                        }).is_err() {
+                            break;
+                        }
+                    }
+                });
+            }
+            SftpCommand::UploadEditedFile {
+                local_path,
+                remote_path,
+            } => {
+                let handle_clone = handle.clone();
+                let events_clone = events.clone();
+                let tab_id_clone = tab_id.clone();
+
+                tokio::spawn(async move {
+                    let flag = TransferStateFlag::new();
+                    let Ok(channel) = handle_clone.channel_open_session().await else {
+                        return;
+                    };
+                    let Ok(_) = channel.request_subsystem(true, "sftp").await else {
+                        return;
+                    };
+                    let Ok(sftp_session) = SftpSession::new(channel.into_stream()).await else {
+                        return;
+                    };
+
+                    let transferred = Arc::new(AtomicU64::new(0));
+                    match upload_file_impl(
+                        &sftp_session,
+                        Path::new(&local_path),
+                        &remote_path,
+                        &flag,
+                        &events_clone,
+                        &tab_id_clone,
+                        "edit-upload",
+                        transferred,
+                        None,
+                    )
+                    .await
+                    {
+                        Ok(_) => {
+                            let now = chrono::Local::now().format("%H:%M:%S");
+                            let _ = events_clone.send(BackendEvent::SftpStatus {
+                                tab_id: tab_id_clone.clone(),
+                                text: format!("{} ({})", t!("auto_saved_and_uploaded", base = base_name(&remote_path)), now),
+                            });
+                        }
+                        Err(err) => {
+                            let _ = events_clone.send(BackendEvent::SftpStatus {
+                                tab_id: tab_id_clone.clone(),
+                                text: format!("Auto-upload failed: {err:#}"),
+                            });
+                        }
+                    }
+                });
+            }
+            SftpCommand::CreateDir(path) => {
+                let actual_path = if path == "~" {
+                    home.clone()
+                } else if let Some(rest) = path.strip_prefix("~/") {
+                    crate::sftp::join_remote(&home, rest)
+                } else {
+                    path.clone()
+                };
+
+                match sftp.create_dir(&actual_path).await {
+                    Ok(_) => {
+                        let _ = events.send(BackendEvent::SftpStatus {
+                            tab_id: tab_id.clone(),
+                            text: t!("create_folder_success", name = base_name(&actual_path)).to_string(),
+                        });
+                        
+                        // Re-fetch the parent directory to show the newly created folder
+                        if let Some(parent) = parent_dir(&actual_path) {
+                            let _ = commands_tx.send(SftpCommand::ListDir(parent));
+                        } else {
+                            let _ = commands_tx.send(SftpCommand::ListDir("/".to_string()));
+                        }
+                    }
+                    Err(err) => {
+                        let _ = events.send(BackendEvent::SftpStatus {
+                            tab_id: tab_id.clone(),
+                            text: t!("create_folder_failed", err = format!("{err:#}")).to_string(),
+                        });
+                    }
+                }
+            }
+            SftpCommand::DeletePaths(paths) => {
+                let _ = events.send(BackendEvent::SftpStatus {
+                    tab_id: tab_id.clone(),
+                    text: t!("deleting_paths", count = paths.len()).to_string(),
+                });
+
+                let mut errors = Vec::new();
+                for path in paths.clone() {
+                    let actual_path = if path == "~" {
+                        home.clone()
+                    } else if let Some(rest) = path.strip_prefix("~/") {
+                        crate::sftp::join_remote(&home, rest)
+                    } else {
+                        path.clone()
+                    };
+
+                    if let Err(e) = recursive_delete(&sftp, actual_path).await {
+                        errors.push(format!("{path}: {e:#}"));
+                    }
+                }
+
+                if errors.is_empty() {
+                    let _ = events.send(BackendEvent::SftpStatus {
+                        tab_id: tab_id.clone(),
+                        text: t!("delete_success", count = paths.len()).to_string(),
+                    });
+                } else {
+                    let _ = events.send(BackendEvent::SftpStatus {
+                        tab_id: tab_id.clone(),
+                        text: t!("delete_failed", err = errors.join(", ")).to_string(),
+                    });
+                }
+
+                if let Some(first) = paths.first() {
+                    let actual_path = if first == "~" {
+                        home.clone()
+                    } else if let Some(rest) = first.strip_prefix("~/") {
+                        crate::sftp::join_remote(&home, rest)
+                    } else {
+                        first.clone()
+                    };
+                    if let Some(parent) = parent_dir(&actual_path) {
+                        let _ = commands_tx.send(SftpCommand::ListDir(parent));
+                    } else {
+                        let _ = commands_tx.send(SftpCommand::ListDir("/".to_string()));
+                    }
+                }
+            }
         }
     }
 
@@ -431,6 +720,43 @@ async fn run_sftp(
     Ok(())
 }
 
+use std::future::Future;
+use std::pin::Pin;
+
+fn recursive_delete<'a>(
+    sftp: &'a SftpSession,
+    path: String,
+) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'a>> {
+    Box::pin(async move {
+        match sftp.read_dir(&path).await {
+            Ok(entries) => {
+                for entry in entries {
+                    let name = entry.file_name();
+                    if name == "." || name == ".." {
+                        continue;
+                    }
+                    let child_path = crate::sftp::join_remote(&path, &name);
+                    
+                    let meta = entry.metadata();
+                    let permissions = meta.permissions.unwrap_or(0);
+                    let is_dir = (permissions & 0o170_000) == 0o040_000;
+                    
+                    if is_dir {
+                        recursive_delete(sftp, child_path).await?;
+                    } else {
+                        sftp.remove_file(&child_path).await.with_context(|| format!("Failed to delete file {child_path}"))?;
+                    }
+                }
+                sftp.remove_dir(&path).await.with_context(|| format!("Failed to delete dir {path}"))?;
+            }
+            Err(_) => {
+                sftp.remove_file(&path).await.with_context(|| format!("Failed to delete {path}"))?;
+            }
+        }
+        Ok(())
+    })
+}
+
 async fn emit_entries(
     events: &std::sync::mpsc::Sender<BackendEvent>,
     tab_id: &str,
@@ -571,7 +897,23 @@ fn base_name(path: &str) -> String {
         .to_string()
 }
 
-fn join_remote(parent: &str, child: &str) -> String {
+pub(crate) fn parent_dir(path: &str) -> Option<String> {
+    if path == "/" || path.is_empty() {
+        return None;
+    }
+    let trimmed = path.trim_end_matches('/');
+    if let Some(idx) = trimmed.rfind('/') {
+        if idx == 0 {
+            Some("/".to_string())
+        } else {
+            Some(trimmed[..idx].to_string())
+        }
+    } else {
+        Some("/".to_string())
+    }
+}
+
+pub(crate) fn join_remote(parent: &str, child: &str) -> String {
     if parent == "/" {
         format!("/{child}")
     } else {
@@ -736,8 +1078,17 @@ async fn download_path_impl(
             base_name(remote),
             Uuid::new_v4()
         ));
-        let extracted_to =
-            download_remote_directory_archive(handle, sftp, remote, &local_archive, &flag, events, tab_id, id).await?;
+        let extracted_to = download_remote_directory_archive(
+            handle,
+            sftp,
+            remote,
+            &local_archive,
+            &flag,
+            events,
+            tab_id,
+            id,
+        )
+        .await?;
         return Ok(t!("downloaded_folder", path = extracted_to.display()).to_string());
     }
 
@@ -763,9 +1114,27 @@ async fn download_dir_recursive(
     for entry in entries {
         let local_path = local_dir.join(&entry.name);
         if entry.is_dir {
-            Box::pin(download_dir_recursive(sftp, &entry.full_path, &local_path, flag, events, tab_id, id)).await?;
+            Box::pin(download_dir_recursive(
+                sftp,
+                &entry.full_path,
+                &local_path,
+                flag,
+                events,
+                tab_id,
+                id,
+            ))
+            .await?;
         } else {
-            download_file_impl(sftp, &entry.full_path, &local_path, flag, events, tab_id, id).await?;
+            download_file_impl(
+                sftp,
+                &entry.full_path,
+                &local_path,
+                flag,
+                events,
+                tab_id,
+                id,
+            )
+            .await?;
             let _ = maybe_extract_archive(&local_path).await;
         }
     }
@@ -794,7 +1163,16 @@ async fn download_remote_directory_archive(
         .join(base_name(remote_dir));
 
     let archive_download = async {
-        download_file_impl(sftp, &remote_archive, local_archive, flag, events, tab_id, id).await?;
+        download_file_impl(
+            sftp,
+            &remote_archive,
+            local_archive,
+            flag,
+            events,
+            tab_id,
+            id,
+        )
+        .await?;
         extract_archive_to(
             local_archive,
             local_archive.parent().unwrap_or_else(|| Path::new(".")),
@@ -839,7 +1217,8 @@ async fn download_file_impl(
 
     let mut buffer = vec![0u8; 128 * 1024];
     loop {
-        flag.yield_if_paused(events, tab_id, id, transferred, total).await?;
+        flag.yield_if_paused(events, tab_id, id, transferred, total)
+            .await?;
         let read = remote_file
             .read(&mut buffer)
             .await
@@ -851,7 +1230,7 @@ async fn download_file_impl(
             .write_all(&buffer[..read])
             .await
             .with_context(|| format!("write {}", local.display()))?;
-            
+
         transferred += read as u64;
         let _ = events.send(BackendEvent::TransferProgress {
             tab_id: tab_id.to_string(),
@@ -862,7 +1241,7 @@ async fn download_file_impl(
         });
     }
     local_file.flush().await.context("flush local file")?;
-    
+
     let _ = events.send(BackendEvent::TransferProgress {
         tab_id: tab_id.to_string(),
         id: id.to_string(),
@@ -870,7 +1249,7 @@ async fn download_file_impl(
         total,
         state: crate::terminal::TransferState::Completed,
     });
-    
+
     Ok(())
 }
 
@@ -886,7 +1265,7 @@ async fn upload_paths_impl(
     create_remote_dir_all(sftp, remote_dir).await?;
     let mut file_count = 0usize;
     let mut folder_count = 0usize;
-    
+
     let mut total_bytes = 0u64;
     let mut files_to_upload = Vec::new();
     let mut dirs_to_create = Vec::new();
@@ -902,14 +1281,20 @@ async fn upload_paths_impl(
             for entry in WalkDir::new(&p) {
                 let entry = entry?;
                 let path = entry.path();
-                if path == p { continue; }
+                if path == p {
+                    continue;
+                }
 
                 if let Ok(meta) = tokio::fs::metadata(&path).await {
                     let relative = path.strip_prefix(&p)?;
                     let remote_path = if relative.as_os_str().is_empty() {
                         remote_root.clone()
                     } else {
-                        let rel = relative.components().map(|c| c.as_os_str().to_string_lossy().to_string()).collect::<Vec<_>>().join("/");
+                        let rel = relative
+                            .components()
+                            .map(|c| c.as_os_str().to_string_lossy().to_string())
+                            .collect::<Vec<_>>()
+                            .join("/");
                         join_remote(&remote_root, &rel)
                     };
 
@@ -929,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?;
@@ -955,7 +1341,8 @@ async fn upload_paths_impl(
                 &id_clone,
                 transferred_clone,
                 Some(total_bytes),
-            ).await
+            )
+            .await
         });
     }
 
@@ -964,7 +1351,7 @@ async fn upload_paths_impl(
     while let Some(res) = stream.next().await {
         res?;
     }
-    
+
     let _ = events.send(BackendEvent::TransferProgress {
         tab_id: tab_id.to_string(),
         id: id.to_string(),
@@ -972,7 +1359,7 @@ async fn upload_paths_impl(
         total: Some(total_bytes),
         state: crate::terminal::TransferState::Completed,
     });
-    
+
     let summary = if file_count == 1 && folder_count == 0 {
         t!("uploaded_file").to_string()
     } else if file_count == 0 && folder_count == 1 {
@@ -982,14 +1369,19 @@ async fn upload_paths_impl(
     } else if file_count == 0 && folder_count > 0 {
         t!("uploaded_n_folders", folders = folder_count).to_string()
     } else {
-        t!("uploaded_files_and_folders", files = file_count, folders = folder_count).to_string()
+        t!(
+            "uploaded_files_and_folders",
+            files = file_count,
+            folders = folder_count
+        )
+        .to_string()
     };
     Ok(summary)
 }
 
 async fn upload_file_impl(
-    sftp: &SftpSession, 
-    local_file: &Path, 
+    sftp: &SftpSession,
+    local_file: &Path,
     remote_path: &str,
     flag: &TransferStateFlag,
     events: &std::sync::mpsc::Sender<BackendEvent>,
@@ -1018,7 +1410,7 @@ async fn upload_file_impl(
             .write_all(&buffer[..read])
             .await
             .with_context(|| format!("write remote {remote_path}"))?;
-            
+
         let new_cur = transferred.fetch_add(read as u64, Ordering::Relaxed) + read as u64;
         let _ = events.send(BackendEvent::TransferProgress {
             tab_id: tab_id.to_string(),

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.rs

@@ -61,6 +61,10 @@ pub enum BackendEvent {
         tab_id: String,
         reason: String,
     },
+    SftpHome {
+        tab_id: String,
+        home: String,
+    },
     TransferProgress {
         #[allow(dead_code)]
         tab_id: String,
@@ -159,6 +163,7 @@ pub struct SftpUiState {
     pub selected_path: Option<String>,
     pub preview: Option<PreviewData>,
     pub selected_entries: std::collections::HashSet<String>,
+    pub home_dir: String,
 }
 
 impl TerminalTab {
@@ -204,6 +209,7 @@ impl TerminalTab {
             selected_path: None,
             preview: None,
             selected_entries: std::collections::HashSet::new(),
+            home_dir: "/".into(),
         });
         tab
     }

src/terminal_element.rs

@@ -144,6 +144,8 @@ pub struct PrepaintState {
 struct TerminalInputHandler {
     view: Entity<Ashell>,
     element_bounds: Bounds<Pixels>,
+    cell_width: f32,
+    line_height: f32,
 }
 
 impl InputHandler for TerminalInputHandler {
@@ -219,7 +221,7 @@ impl InputHandler for TerminalInputHandler {
     ) -> Option<Bounds<Pixels>> {
         self.view
             .read(cx)
-            .terminal_ime_bounds_for_range(range_utf16, self.element_bounds)
+            .terminal_ime_bounds_for_range(range_utf16, self.element_bounds, self.cell_width, self.line_height)
     }
 
     fn character_index_for_point(
@@ -492,6 +494,8 @@ impl Element for TerminalElement {
             TerminalInputHandler {
                 view: self.view.clone(),
                 element_bounds: prepaint.bounds,
+                cell_width: prepaint.metrics.cell_width.as_f32(),
+                line_height: prepaint.metrics.line_height.as_f32(),
             },
             cx,
         );

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
+            })
+    }
+}