bump version to v0.4.8

Cargo.lock

@@ -315,7 +315,7 @@ dependencies = [
 
 [[package]]
 name = "ashell"
-version = "0.4.7"
+version = "0.4.8"
 dependencies = [
  "alacritty_terminal",
  "anyhow",
@@ -355,6 +355,7 @@ dependencies = [
  "thiserror 1.0.69",
  "time",
  "tokio",
+ "tokio-socks",
  "tracing",
  "tracing-appender",
  "tracing-subscriber",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ashell"
-version = "0.4.7"
+version = "0.4.8"
 edition = "2024"
 authors = ["ashell contributors"]
 description = "A GPUI Component based SSH and local terminal client"
@@ -9,6 +9,7 @@ rust-version = "1.85.0"
 
 [dependencies]
 anyhow = "1"
+tokio-socks = "0.5"
 alacritty_terminal = { git = "https://github.com/zed-industries/alacritty", rev = "fcf32feacb367b75ec84dd40f041e4fd411d3cc1" }
 async-trait = "0.1"
 chrono = { version = "0.4", features = ["serde"] }

locales/en.yml

@@ -62,11 +62,22 @@ add_ssh: "+ ssh"
 open_local_or_ssh: "Open a local terminal or pick an SSH session."
 open_session: "Open Session"
 settings: "Settings"
+proxy: "Proxy"
+proxy_none: "Follow Global"
+proxy_host: "Proxy Host"
+proxy_port: "Proxy Port"
+proxy_user: "Proxy Username (optional)"
+proxy_password: "Proxy Password (optional)"
 ui_font_size: "UI Font Size"
 terminal_font_size: "Terminal Font Size"
 system_default: "System Default"
 ui_font_family: "UI Font"
 terminal_font_family: "Terminal Font"
+cursor_style: "Cursor Style"
+cursor_style_default: "Default"
+cursor_style_blink: "Blink"
+cursor_style_beam: "Line"
+cursor_style_beam_blink: "Line Blink"
 monitoring_position: "Monitoring Position"
 position_bottom: "Bottom"
 position_sidebar: "Sidebar"
@@ -76,6 +87,8 @@ local_terminal_opened: "local terminal opened"
 connecting: "Connecting"
 starting_connection: "starting connection..."
 connection_failed: "Connection Failed"
+session_disconnected: "Session disconnected: %{reason}"
+press_enter_to_reconnect: "Press Enter to reconnect"
 
 preview_failed: "Preview failed: %{err}"
 downloading_file: "Downloading %{base}..."
@@ -112,7 +125,9 @@ software_builtin: "Built-in"
 retry: "Retry"
 right_click_copy_paste: "Right-click Copy/Paste"
 keyword_highlight: "Terminal Keyword Highlighting"
-copy_paste_hint: "Regardless of this switch, you can always use %{key} + C/V to copy/paste."
+copy_paste_hint: "Selected text can also be copied by left-clicking."
+settings_copy: "Copy Selection"
+settings_paste: "Paste Clipboard"
 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}"
@@ -184,3 +199,15 @@ sync_upload_complete: "Configuration uploaded"
 sync_download_complete: "Configuration downloaded"
 sync_failed: "Synchronization failed"
 keyboard_interactive: "Keyboard Interactive"
+settings_proxy: "Proxy"
+enable_proxy: "Enable Proxy"
+read_env_proxy: "Read environment variables on startup"
+read_env_proxy_desc: "If enabled, the global proxy settings below will be overridden by environment variables on startup."
+global_proxy_settings: "Global Proxy Configuration"
+global_proxy_type: "Proxy Type"
+global_proxy_host: "Proxy Host"
+global_proxy_port: "Proxy Port"
+global_proxy_user: "Proxy Username"
+global_proxy_password: "Proxy Password"
+save_proxy: "Save Proxy"
+

locales/zh-CN.yml

@@ -63,11 +63,22 @@ add_ssh: "+ SSH"
 open_local_or_ssh: "打开本地终端或选择一个 SSH 会话。"
 open_session: "打开会话"
 settings: "设置"
+proxy: "代理"
+proxy_none: "跟随全局"
+proxy_host: "代理服务器地址"
+proxy_port: "端口"
+proxy_user: "用户名 (可选)"
+proxy_password: "密码 (可选)"
 ui_font_size: "界面字体大小"
 terminal_font_size: "终端字体大小"
 system_default: "系统默认"
 ui_font_family: "界面字体"
 terminal_font_family: "终端字体"
+cursor_style: "光标样式"
+cursor_style_default: "默认"
+cursor_style_blink: "闪烁"
+cursor_style_beam: "细线"
+cursor_style_beam_blink: "细线闪烁"
 monitoring_position: "系统监控显示位置"
 position_bottom: "底部"
 position_sidebar: "侧边栏"
@@ -77,6 +88,8 @@ local_terminal_opened: "已打开本地终端"
 connecting: "正在连接"
 starting_connection: "开始连接..."
 connection_failed: "连接失败"
+session_disconnected: "会话已断开: %{reason}"
+press_enter_to_reconnect: "按 Enter 重新连接"
 
 preview_failed: "预览失败: %{err}"
 downloading_file: "正在下载 %{base}..."
@@ -113,7 +126,9 @@ software_builtin: "软件内置"
 retry: "重试"
 right_click_copy_paste: "右键复制/粘贴"
 keyword_highlight: "终端关键词高亮"
-copy_paste_hint: "不管是否开启此开关，都可以使用 %{key} + C/V 快捷键进行复制和粘贴。"
+copy_paste_hint: "选中后左键点击也可复制。"
+settings_copy: "复制选区"
+settings_paste: "粘贴剪贴板"
 edit_file: "编辑文件"
 edit_file_tooltip: "下载到临时目录，使用默认编辑器打开，并在保存后自动上传。"
 auto_saved_and_uploaded: "已自动保存并上传: %{base}"
@@ -186,3 +201,15 @@ sync_upload_complete: "配置上传完成"
 sync_download_complete: "配置下载完成"
 sync_failed: "同步失败"
 keyboard_interactive: "键盘交互"
+settings_proxy: "代理设置"
+enable_proxy: "启用代理功能"
+read_env_proxy: "启动时读取环境变量"
+read_env_proxy_desc: "若开启此项，启动时将读取环境变量，下方配置的全局代理设置将失效。"
+global_proxy_settings: "全局代理配置"
+global_proxy_type: "代理类型"
+global_proxy_host: "代理地址"
+global_proxy_port: "代理端口"
+global_proxy_user: "代理用户名"
+global_proxy_password: "代理密码"
+save_proxy: "保存代理设置"
+

src/app/dialogs.rs

@@ -36,6 +36,10 @@ impl Ashell {
         let key_path_input = self.key_path_input.clone();
         let key_inline_input = self.key_inline_input.clone();
         let passphrase_input = self.passphrase_input.clone();
+        let proxy_host_input = self.proxy_host_input.clone();
+        let proxy_port_input = self.proxy_port_input.clone();
+        let proxy_user_input = self.proxy_user_input.clone();
+        let proxy_password_input = self.proxy_password_input.clone();
 
         window.open_dialog(cx, move |dialog: Dialog, _window, _cx| {
             dialog
@@ -61,12 +65,18 @@ impl Ashell {
                     let key_path_input = key_path_input.clone();
                     let key_inline_input = key_inline_input.clone();
                     let passphrase_input = passphrase_input.clone();
+                    let proxy_host_input = proxy_host_input.clone();
+                    let proxy_port_input = proxy_port_input.clone();
+                    let proxy_user_input = proxy_user_input.clone();
+                    let proxy_password_input = proxy_password_input.clone();
                     move |content, window, cx| {
                         let method = view.read(cx).ssh_auth_method;
                         let is_password = method == AuthMethod::Password;
                         let is_key = method == AuthMethod::Key;
                         let is_kb = method == AuthMethod::KeyboardInteractive;
                         let is_editing = view.read(cx).editing_session_id.is_some();
+                        let proxy_type = view.read(cx).ssh_proxy_type.clone();
+                        let show_proxy_fields = proxy_type != "none";
                         content.child(
                             v_flex()
                                 .gap_3()
@@ -170,6 +180,60 @@ impl Ashell {
                                     .child(Input::new(&key_inline_input).h(px(128.)).tab_index(5))
                                     .child(Input::new(&passphrase_input).mask_toggle().tab_index(6))
                                 })
+                                .child(
+                                    div().text_sm().font_weight(FontWeight::BOLD).child(t!("proxy").to_string())
+                                )
+                                .child(
+                                    h_flex()
+                                        .gap_2()
+                                        .child(
+                                            Button::new("proxy-none")
+                                                .label(t!("proxy_none").to_string())
+                                                .when(proxy_type == "none", |button| button.primary())
+                                                .on_click(window.listener_for(
+                                                    &view,
+                                                    |this, _, _, cx| {
+                                                        this.set_ssh_proxy_type("none".to_string(), cx)
+                                                    },
+                                                )),
+                                        )
+                                        .child(
+                                            Button::new("proxy-socks5")
+                                                .label("SOCKS5")
+                                                .when(proxy_type == "socks5", |button| button.primary())
+                                                .on_click(window.listener_for(
+                                                    &view,
+                                                    |this, _, _, cx| {
+                                                        this.set_ssh_proxy_type("socks5".to_string(), cx)
+                                                    },
+                                                )),
+                                        )
+                                        .child(
+                                            Button::new("proxy-http")
+                                                .label("HTTP")
+                                                .when(proxy_type == "http", |button| button.primary())
+                                                .on_click(window.listener_for(
+                                                    &view,
+                                                    |this, _, _, cx| {
+                                                        this.set_ssh_proxy_type("http".to_string(), cx)
+                                                    },
+                                                )),
+                                        )
+                                )
+                                .when(show_proxy_fields, |this| {
+                                    this.child(
+                                        h_flex()
+                                            .gap_2()
+                                            .child(Input::new(&proxy_host_input).flex_1())
+                                            .child(Input::new(&proxy_port_input).w(px(96.)))
+                                    )
+                                    .child(
+                                        h_flex()
+                                            .gap_2()
+                                            .child(Input::new(&proxy_user_input).flex_1())
+                                            .child(Input::new(&proxy_password_input).flex_1())
+                                    )
+                                })
                                 .child(
                                     h_flex()
                                         .justify_end()
@@ -1521,6 +1585,58 @@ impl Ashell {
                                                         })
                                                     )
                                                 )
+                                                .item(
+                                                    SettingItem::new(
+                                                        t!("cursor_style").to_string(),
+                                                        SettingField::render({
+                                                            let view = view_clone_for_general.clone();
+                                                            move |_, _window, cx| {
+                                                                use crate::session::config::CursorStyle;
+                                                                let current = view.read(cx).cursor_style;
+                                                                Button::new("cursor-style-dropdown")
+                                                                    .small()
+                                                                    .icon(IconName::ChevronsUpDown)
+                                                                    .label(match current {
+                                                                        CursorStyle::Default => t!("cursor_style_default").to_string(),
+                                                                        CursorStyle::Blink => t!("cursor_style_blink").to_string(),
+                                                                        CursorStyle::Beam => t!("cursor_style_beam").to_string(),
+                                                                        CursorStyle::BeamBlink => t!("cursor_style_beam_blink").to_string(),
+                                                                    })
+                                                                    .dropdown_menu_with_anchor(Anchor::BottomRight, {
+                                                                        let view = view.clone();
+                                                                        move |mut menu, window, cx| {
+                                                                            use crate::session::config::CursorStyle;
+                                                                            let current = view.read(cx).cursor_style;
+                                                                            menu = menu.min_w(160.).max_h(px(320.)).scrollable(true);
+                                                                            for style in [
+                                                                                CursorStyle::Default,
+                                                                                CursorStyle::Blink,
+                                                                                CursorStyle::Beam,
+                                                                                CursorStyle::BeamBlink,
+                                                                            ] {
+                                                                                let checked = style == current;
+                                                                                let label = match style {
+                                                                                    CursorStyle::Default => t!("cursor_style_default").to_string(),
+                                                                                    CursorStyle::Blink => t!("cursor_style_blink").to_string(),
+                                                                                    CursorStyle::Beam => t!("cursor_style_beam").to_string(),
+                                                                                    CursorStyle::BeamBlink => t!("cursor_style_beam_blink").to_string(),
+                                                                                };
+                                                                                menu = menu.item(
+                                                                                    PopupMenuItem::new(label)
+                                                                                        .checked(checked)
+                                                                                        .on_click(window.listener_for(&view, move |this, _, _window, cx| {
+                                                                                            this.change_cursor_style(style, cx);
+                                                                                        }))
+                                                                                );
+                                                                            }
+                                                                            menu
+                                                                        }
+                                                                    })
+                                                                    .into_any_element()
+                                                            }
+                                                        })
+                                                    )
+                                                )
                                         )
                                         .group(
                                             SettingGroup::new()
@@ -1542,7 +1658,7 @@ impl Ashell {
                                                                     .into_any_element()
                                                             }
                                                         })
-                                                    ).description(t!("copy_paste_hint", key = if cfg!(target_os = "macos") { "Command" } else { "Ctrl" }).to_string())
+                                                    ).description(t!("copy_paste_hint").to_string())
                                                 )
                                                 .item(
                                                     SettingItem::new(
@@ -1765,6 +1881,119 @@ impl Ashell {
                                                 }))
                                         )
                                 )
+                                .page(
+                                    SettingPage::new(t!("settings_proxy").to_string())
+                                        .icon(IconName::Network)
+                                        .group(
+                                            SettingGroup::new()
+                                                .title(t!("settings_proxy").to_string())
+                                                .item(
+                                                    SettingItem::new(
+                                                        t!("enable_proxy").to_string(),
+                                                        SettingField::render({
+                                                            let view = view.clone();
+                                                            move |_, window, cx| {
+                                                                Switch::new("use-proxy")
+                                                                    .small()
+                                                                    .checked(view.read(cx).config.use_proxy())
+                                                                    .on_click(window.listener_for(&view, |this, checked, _, cx| {
+                                                                        this.config.set_use_proxy(*checked);
+                                                                        let _ = this.config.save();
+                                                                        cx.notify();
+                                                                    }))
+                                                                    .into_any_element()
+                                                            }
+                                                        })
+                                                    )
+                                                )
+                                                .item(
+                                                    SettingItem::new(
+                                                        t!("read_env_proxy").to_string(),
+                                                        SettingField::render({
+                                                            let view = view.clone();
+                                                            move |_, window, cx| {
+                                                                Switch::new("read-env-proxy")
+                                                                    .small()
+                                                                    .checked(view.read(cx).config.read_env_proxy())
+                                                                    .on_click(window.listener_for(&view, |this, checked, _, cx| {
+                                                                        this.config.set_read_env_proxy(*checked);
+                                                                        let _ = this.config.save();
+                                                                        cx.notify();
+                                                                    }))
+                                                                    .into_any_element()
+                                                            }
+                                                        })
+                                                    ).description(t!("read_env_proxy_desc").to_string())
+                                                )
+                                                .item(SettingItem::render({
+                                                    let view = view.clone();
+                                                    let global_proxy_host_input = view.read(cx).global_proxy_host_input.clone();
+                                                    let global_proxy_port_input = view.read(cx).global_proxy_port_input.clone();
+                                                    let global_proxy_user_input = view.read(cx).global_proxy_user_input.clone();
+                                                    let global_proxy_password_input = view.read(cx).global_proxy_password_input.clone();
+                                                    move |_, window, cx| {
+                                                        let proxy_type = view.read(cx).global_proxy_type.clone();
+                                                        v_flex()
+                                                            .w_full()
+                                                            .gap_3()
+                                                            .child(div().text_sm().font_weight(FontWeight::BOLD).child(t!("global_proxy_settings").to_string()))
+                                                            .child(
+                                                                h_flex()
+                                                                    .gap_2()
+                                                                    .child(
+                                                                        Button::new("global-proxy-type-socks5")
+                                                                            .small()
+                                                                            .label("SOCKS5")
+                                                                            .when(proxy_type == "socks5", |b| b.primary())
+                                                                            .on_click(window.listener_for(&view, |this, _, _, cx| {
+                                                                                this.global_proxy_type = "socks5".to_string();
+                                                                                cx.notify();
+                                                                            }))
+                                                                    )
+                                                                    .child(
+                                                                        Button::new("global-proxy-type-http")
+                                                                            .small()
+                                                                            .label("HTTP")
+                                                                            .when(proxy_type == "http", |b| b.primary())
+                                                                            .on_click(window.listener_for(&view, |this, _, _, cx| {
+                                                                                this.global_proxy_type = "http".to_string();
+                                                                                cx.notify();
+                                                                            }))
+                                                                    )
+                                                            )
+                                                            .child(v_flex().gap_1().child(div().text_sm().child(t!("global_proxy_host").to_string())).child(Input::new(&global_proxy_host_input).w_full()))
+                                                            .child(v_flex().gap_1().child(div().text_sm().child(t!("global_proxy_port").to_string())).child(Input::new(&global_proxy_port_input).w_full()))
+                                                            .child(v_flex().gap_1().child(div().text_sm().child(t!("global_proxy_user").to_string())).child(Input::new(&global_proxy_user_input).w_full()))
+                                                            .child(v_flex().gap_1().child(div().text_sm().child(t!("global_proxy_password").to_string())).child(Input::new(&global_proxy_password_input).w_full()))
+                                                            .child(
+                                                                Button::new("save-global-proxy")
+                                                                    .small()
+                                                                    .primary()
+                                                                    .label(t!("save_proxy").to_string())
+                                                                    .on_click(window.listener_for(&view, |this, _, _, cx| {
+                                                                        let host = this.global_proxy_host_input.read(cx).value().trim().to_string();
+                                                                        let port_str = this.global_proxy_port_input.read(cx).value();
+                                                                        let port = port_str.trim().parse::<u16>().ok();
+                                                                        let user = this.global_proxy_user_input.read(cx).value().trim().to_string();
+                                                                        let password = this.global_proxy_password_input.read(cx).value().to_string();
+                                                                        
+                                                                        if host.is_empty() || port.is_none() {
+                                                                            return;
+                                                                        }
+                                                                        
+                                                                        this.config.set_global_proxy_type(this.global_proxy_type.clone());
+                                                                        this.config.set_global_proxy_host(host);
+                                                                        this.config.set_global_proxy_port(port);
+                                                                        this.config.set_global_proxy_user(user);
+                                                                        this.config.set_global_proxy_password(password);
+                                                                        let _ = this.config.save();
+                                                                        cx.notify();
+                                                                    }))
+                                                            )
+                                                    }
+                                                }))
+                                        )
+                                )
                                 .page({
                                     let mut page = SettingPage::new(t!("settings_key_bindings").to_string())
                                         .icon(IconName::SquareTerminal)
@@ -1876,7 +2105,7 @@ impl Ashell {
                         this.active_dialog = None;
                         // Send Close command to abort connection if they close the dialog without OK
                         if let Some(tab) = this.tabs.iter().find(|t| t.id == tab_id_for_close) {
-                            tab.backend.send(crate::terminal::BackendCommand::Close);
+                            tab.send_backend(crate::terminal::BackendCommand::Close);
                         }
                         cx.notify();
                     });
@@ -1889,7 +2118,7 @@ impl Ashell {
                             responses.push(state.read(cx).text().to_string());
                         }
                         if let Some(tab) = this.tabs.iter().find(|t| t.id == tab_id_for_ok) {
-                            tab.backend.send(crate::terminal::BackendCommand::PromptResponse(responses));
+                            tab.send_backend(crate::terminal::BackendCommand::PromptResponse(responses));
                         }
                         cx.notify();
                     });

src/app/keybinding_recorder.rs

@@ -29,7 +29,9 @@ gpui::actions!(
         SplitPaneRight,
         SplitPaneUp,
         SplitPaneDown,
-        ClosePane
+        ClosePane,
+        Copy,
+        Paste
     ]
 );
 
@@ -123,6 +125,16 @@ pub(crate) const WORKSPACE_ACTIONS: &[WorkspaceAction] = &[
         label_key: "settings_close_pane",
         default_suffix: "w",
     },
+    WorkspaceAction {
+        id: "Copy",
+        label_key: "settings_copy",
+        default_suffix: if cfg!(target_os = "macos") { "c" } else { "shift-c" },
+    },
+    WorkspaceAction {
+        id: "Paste",
+        label_key: "settings_paste",
+        default_suffix: if cfg!(target_os = "macos") { "v" } else { "shift-v" },
+    },
 ];
 
 pub(crate) fn default_modifier() -> &'static str {
@@ -224,6 +236,8 @@ pub(crate) fn unbind_all_workspace_keys(cx: &mut App, config: &ConfigStore) {
     unbind_action!("SplitPaneUp", crate::SplitPaneUp);
     unbind_action!("SplitPaneDown", crate::SplitPaneDown);
     unbind_action!("ClosePane", crate::ClosePane);
+    unbind_action!("Copy", crate::Copy);
+    unbind_action!("Paste", crate::Paste);
 
     cx.bind_keys(bindings);
 }
@@ -280,6 +294,8 @@ fn bind_workspace_actions(cx: &mut App, config: &ConfigStore) {
     bind_action!("SplitPaneUp", crate::SplitPaneUp);
     bind_action!("SplitPaneDown", crate::SplitPaneDown);
     bind_action!("ClosePane", crate::ClosePane);
+    bind_action!("Copy", crate::Copy);
+    bind_action!("Paste", crate::Paste);
 
     cx.bind_keys(bindings);
 }
@@ -289,7 +305,7 @@ impl KeybindingsPage {
         let groups = [
             (
                 "settings_group_keybind_general",
-                vec!["OpenSettings", "OpenSession", "OpenTransfers", "NewSsh", "OpenSearch"],
+                vec!["OpenSettings", "OpenSession", "OpenTransfers", "NewSsh", "OpenSearch", "Copy", "Paste"],
             ),
             (
                 "settings_group_keybind_zoom",

src/app/mod.rs

@@ -211,6 +211,16 @@ pub(crate) struct Ashell {
     pub(crate) key_path_input: Entity<InputState>,
     pub(crate) key_inline_input: Entity<InputState>,
     pub(crate) passphrase_input: Entity<InputState>,
+    pub(crate) ssh_proxy_type: String,
+    pub(crate) proxy_host_input: Entity<InputState>,
+    pub(crate) proxy_port_input: Entity<InputState>,
+    pub(crate) proxy_user_input: Entity<InputState>,
+    pub(crate) proxy_password_input: Entity<InputState>,
+    pub(crate) global_proxy_type: String,
+    pub(crate) global_proxy_host_input: Entity<InputState>,
+    pub(crate) global_proxy_port_input: Entity<InputState>,
+    pub(crate) global_proxy_user_input: Entity<InputState>,
+    pub(crate) global_proxy_password_input: Entity<InputState>,
     pub(crate) sync_endpoint_input: Entity<InputState>,
     pub(crate) sync_username_input: Entity<InputState>,
     pub(crate) sync_webdav_password_input: Entity<InputState>,
@@ -249,8 +259,6 @@ pub(crate) struct Ashell {
     pub(crate) tabs_scroll_handle: gpui::ScrollHandle,
     pub(crate) selector_scroll_handle: gpui::ScrollHandle,
     pub(crate) saved_scroll_handle: gpui::ScrollHandle,
-    pub(crate) connection_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,
@@ -275,6 +283,7 @@ pub(crate) struct Ashell {
     pub(crate) status: SharedString,
     pub(crate) config: ConfigStore,
     pub(crate) active_title_bar_style: crate::session::config::TitleBarStyle,
+    pub(crate) cursor_style: crate::session::config::CursorStyle,
     pub(crate) system_sampler: SystemSampler,
     pub(crate) recording_action: Option<String>,
     pub(crate) active_dialog: Option<DialogKind>,
@@ -304,6 +313,8 @@ pub(crate) struct Ashell {
     pub(crate) runtime: Runtime,
     pub(crate) events_rx: mpsc::Receiver<BackendEvent>,
     pub(crate) events_tx: mpsc::Sender<BackendEvent>,
+    pub(crate) last_window_size: Option<gpui::Size<Pixels>>,
+    pub(crate) last_sidebar_width: Option<Pixels>,
     pub(crate) _subscriptions: Vec<gpui::Subscription>,
 }
 
@@ -314,14 +325,6 @@ pub(crate) enum SelectorEntry {
     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,
@@ -374,6 +377,10 @@ impl Ashell {
                 .placeholder("SSH private key passphrase (optional)")
                 .masked(true)
         });
+        let proxy_host_input = cx.new(|cx| InputState::new(window, cx).placeholder(t!("proxy_host").to_string()));
+        let proxy_port_input = cx.new(|cx| InputState::new(window, cx).placeholder(t!("proxy_port").to_string()));
+        let proxy_user_input = cx.new(|cx| InputState::new(window, cx).placeholder(t!("proxy_user").to_string()));
+        let proxy_password_input = cx.new(|cx| InputState::new(window, cx).placeholder(t!("proxy_password").to_string()).masked(true));
         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()));
@@ -384,6 +391,27 @@ impl Ashell {
             tracing::warn!("failed to load config: {err:#}");
             ConfigStore::in_memory()
         });
+        let global_proxy_host_input = cx.new(|cx| {
+            InputState::new(window, cx)
+                .placeholder(t!("proxy_host").to_string())
+                .default_value(config.global_proxy_host())
+        });
+        let global_proxy_port_input = cx.new(|cx| {
+            InputState::new(window, cx)
+                .placeholder(t!("proxy_port").to_string())
+                .default_value(config.global_proxy_port().map(|p| p.to_string()).unwrap_or_default())
+        });
+        let global_proxy_user_input = cx.new(|cx| {
+            InputState::new(window, cx)
+                .placeholder(t!("proxy_user").to_string())
+                .default_value(config.global_proxy_user())
+        });
+        let global_proxy_password_input = cx.new(|cx| {
+            InputState::new(window, cx)
+                .placeholder(t!("proxy_password").to_string())
+                .masked(true)
+                .default_value(config.global_proxy_password())
+        });
         let sync_endpoint_input = cx.new(|cx| {
             InputState::new(window, cx)
                 .placeholder("https://dav.example.com/ashell/")
@@ -447,6 +475,10 @@ impl Ashell {
             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(&passphrase_input, window, Self::on_input_event),
+            cx.subscribe_in(&proxy_host_input, window, Self::on_input_event),
+            cx.subscribe_in(&proxy_port_input, window, Self::on_input_event),
+            cx.subscribe_in(&proxy_user_input, window, Self::on_input_event),
+            cx.subscribe_in(&proxy_password_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),
             cx.subscribe_in(&search_input, window, Self::on_input_event),
@@ -506,6 +538,10 @@ impl Ashell {
         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 last_sidebar_width = Some(px(config
+            .workspace_panels()
+            .and_then(|s| s.first().copied())
+            .unwrap_or(constants::SIDEBAR_WIDTH)));
         let mut this = Self {
             focus_handle: cx.focus_handle(),
             selector_focus_handle: cx.focus_handle(),
@@ -517,6 +553,16 @@ impl Ashell {
             key_path_input,
             key_inline_input,
             passphrase_input,
+            ssh_proxy_type: "none".to_string(),
+            proxy_host_input,
+            proxy_port_input,
+            proxy_user_input,
+            proxy_password_input,
+            global_proxy_type: config.global_proxy_type().to_string(),
+            global_proxy_host_input,
+            global_proxy_port_input,
+            global_proxy_user_input,
+            global_proxy_password_input,
             sync_endpoint_input,
             sync_username_input,
             sync_webdav_password_input,
@@ -539,6 +585,7 @@ impl Ashell {
             dark_theme_name,
             ui_font_size: config.ui_font_size(),
             terminal_font_size: config.terminal_font_size(),
+            cursor_style: config.cursor_style(),
             ui_font_family,
             terminal_font_family,
             tabs: Vec::new(),
@@ -558,8 +605,6 @@ impl Ashell {
             tabs_scroll_handle: gpui::ScrollHandle::new(),
             selector_scroll_handle: gpui::ScrollHandle::new(),
             saved_scroll_handle: gpui::ScrollHandle::new(),
-            connection_scroll_handle: gpui::ScrollHandle::new(),
-            connection_progress: None,
             pending_sftp_path_sync: Some("/".into()),
             sftp_context_menu: None,
             sftp_creating_folder: false,
@@ -621,6 +666,8 @@ impl Ashell {
             runtime: Runtime::new().expect("create tokio runtime"),
             events_rx,
             events_tx,
+            last_window_size: None,
+            last_sidebar_width,
             _subscriptions,
         };
 
@@ -691,6 +738,7 @@ impl Ashell {
     pub(crate) fn start_event_pump(&self, window: &mut Window, cx: &mut Context<Self>) {
         cx.spawn_in(window, async move |this, mut cx| {
             let mut idle_frames = 0u32;
+            let mut last_blink_time = std::time::Instant::now();
             loop {
                 cx.background_executor()
                     .timer(Duration::from_millis(16))
@@ -702,9 +750,19 @@ impl Ashell {
                         changed = this.drain_backend_events(window, cx);
                         system_sampled = this.sample_system_if_due();
                         this.sync_theme_if_due(cx);
-                        if changed || system_sampled {
+                        let is_blinking = matches!(
+                            this.cursor_style,
+                            crate::session::config::CursorStyle::Blink
+                                | crate::session::config::CursorStyle::BeamBlink
+                        );
+                        let now = std::time::Instant::now();
+                        let blink_due = is_blinking && now.duration_since(last_blink_time) >= std::time::Duration::from_millis(600);
+                        if changed || system_sampled || blink_due {
                             cx.notify();
                             idle_frames = 0;
+                            if blink_due {
+                                last_blink_time = now;
+                            }
                         } else {
                             idle_frames += 1;
                             if idle_frames >= 60 {
@@ -730,36 +788,25 @@ impl Ashell {
             match event {
                 BackendEvent::Output { tab_id, bytes } => {
                     if let Some(tab) = self.tabs.iter_mut().find(|t| t.id == tab_id) {
+                        tab.backend_initialized = true;
                         tab.feed(&bytes);
                     }
                 }
                 BackendEvent::Status { tab_id, text } => {
                     if let Some(tab) = self.tabs.iter_mut().find(|t| t.id == tab_id) {
+                        tab.backend_initialized = true;
                         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());
-                            let _idx = progress.lines.len().saturating_sub(1);
-                            self.connection_scroll_handle
-                                .set_offset(point(px(0.), px(-99999.0)));
-                        }
-                    }
                     self.status = text.into();
                 }
                 BackendEvent::Connected { tab_id } => {
                     if let Some(tab) = self.tabs.iter_mut().find(|t| t.id == tab_id) {
+                        tab.backend_initialized = true;
                         tab.connected = true;
+                        tab.disconnected_reason = None;
                     }
                     self.sync_system_tab_to_active_group();
                     self.request_active_system_snapshot();
-                    if self
-                        .connection_progress
-                        .as_ref()
-                        .is_some_and(|progress| progress.tab_id == tab_id && !progress.failed)
-                    {
-                        self.connection_progress = None;
-                    }
                 }
                 BackendEvent::PromptRequest {
                     tab_id,
@@ -835,67 +882,35 @@ impl Ashell {
                 }
                 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)
+                    let is_stale = self
+                        .tabs
+                        .iter()
+                        .find(|t| t.id == tab_id)
+                        .is_some_and(|tab| {
+                            // After retry_disconnected_tab, the old backend's threads
+                            // may still send Closed events. Skip those — they arrive
+                            // before the new backend sends its first Output/Connected.
+                            // Once backend_initialized is set, any Closed is from the
+                            // current backend and should be processed.
+                            tab.backend_generation > 0 && !tab.backend_initialized
                         });
-                    }
-                    if self.system_tab_id.as_deref() == Some(tab_id.as_str()) {
-                        self.system_status = Some(reason.clone().into());
+                    if is_stale {
+                        continue;
                     }
                     let is_graceful_exit =
                         reason == "local shell closed" || reason == "ssh session closed";
-                    // Auto-close the pane on graceful exit (e.g. user typed exit)
                     if is_graceful_exit {
                         self.handle_tab_close(tab_id.clone());
                         self.status = reason.into();
-                        self.remote_sample_in_flight = false;
-                        return changed;
+                        continue;
                     }
-                    let mut needs_new_progress = false;
-                    if let Some(progress) = self.connection_progress.as_mut() {
-                        if progress.tab_id == tab_id {
-                            progress.lines.push(reason.clone().into());
-                            let _idx = progress.lines.len().saturating_sub(1);
-                            self.connection_scroll_handle
-                                .set_offset(point(px(0.), px(-99999.0)));
-                            let _ = session_label;
-                            let _ = tab_title;
-                            progress.title = t!("connection_failed").into();
-                            progress.failed = true;
-                        } else if !progress.failed {
-                            // We were showing connecting progress, but another tab dropped!
-                            // Switch to failed state so the user can see it and retry.
-                            progress.tab_id = tab_id.clone();
-                            let msg = format!("{}: {}", tab_title.unwrap_or_default(), reason);
-                            progress.lines.push(msg.into());
-                            self.connection_scroll_handle
-                                .set_offset(point(px(0.), px(-99999.0)));
-                            progress.title = t!("connection_failed").into();
-                            progress.failed = true;
-                        } else {
-                            // Already showing a failure dialog, just append the new failure
-                            let msg = format!("{}: {}", tab_title.unwrap_or_default(), reason);
-                            progress.lines.push(msg.into());
-                            self.connection_scroll_handle
-                                .set_offset(point(px(0.), px(-99999.0)));
-                        }
-                    } else if let Some(_) = session_label {
-                        needs_new_progress = true;
+                    if let Some(tab) = self.tabs.iter_mut().find(|t| t.id == tab_id) {
+                        tab.connected = false;
+                        tab.status = reason.clone();
+                        tab.disconnected_reason = Some(reason.clone());
                     }
-
-                    if needs_new_progress && !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,
-                        });
+                    if self.system_tab_id.as_deref() == Some(tab_id.as_str()) {
+                        self.system_status = Some(reason.clone().into());
                     }
                     self.status = reason.into();
                 }
@@ -1039,7 +1054,9 @@ impl Ashell {
             return;
         }
         self.remote_sample_in_flight = true;
-        backend.send(crate::terminal::BackendCommand::SampleMetrics);
+        if let Ok(backend) = backend.lock() {
+            backend.send(crate::terminal::BackendCommand::SampleMetrics);
+        }
     }
 
     pub(crate) fn terminal_ime_bounds_for_range(
@@ -1066,4 +1083,90 @@ impl Ashell {
         self.config.set_transfers(self.transfers.clone());
         cx.notify();
     }
+
+    pub(crate) fn save_layout_state(&self, window: &mut gpui::Window, cx: &gpui::App) {
+        if self.is_layout_reset {
+            tracing::info!("[ui] layout was reset, skipping save layout state.");
+            return;
+        }
+        let current_bounds = window.window_bounds();
+        let bounds = match current_bounds {
+            gpui::WindowBounds::Fullscreen(b) => b,
+            gpui::WindowBounds::Maximized(b) => b,
+            gpui::WindowBounds::Windowed(b) => b,
+        };
+        let size = bounds.size;
+        if size.width.as_f32() > 400.0 && size.height.as_f32() > 300.0 {
+            tracing::info!("[ui] saving layout state...");
+            let mut config = ConfigStore::load().unwrap_or_else(|_| ConfigStore::in_memory());
+            let saved_bounds = match current_bounds {
+                gpui::WindowBounds::Fullscreen(b) => {
+                    crate::session::config::SavedWindowBounds::Fullscreen {
+                        x: b.origin.x.into(),
+                        y: b.origin.y.into(),
+                        width: b.size.width.into(),
+                        height: b.size.height.into(),
+                    }
+                }
+                gpui::WindowBounds::Maximized(b) => {
+                    let mut restore_bounds = (b.origin.x.into(), b.origin.y.into(), b.size.width.into(), b.size.height.into());
+                    if let Some(existing_bounds) = config.window_bounds() {
+                        match existing_bounds {
+                            crate::session::config::SavedWindowBounds::Windowed { x, y, width, height } => {
+                                restore_bounds = (*x, *y, *width, *height);
+                            }
+                            crate::session::config::SavedWindowBounds::Maximized { x, y, width, height } => {
+                                restore_bounds = (*x, *y, *width, *height);
+                            }
+                            _ => {}
+                        }
+                    }
+                    crate::session::config::SavedWindowBounds::Maximized {
+                        x: restore_bounds.0,
+                        y: restore_bounds.1,
+                        width: restore_bounds.2,
+                        height: restore_bounds.3,
+                    }
+                }
+                gpui::WindowBounds::Windowed(b) => {
+                    crate::session::config::SavedWindowBounds::Windowed {
+                        x: b.origin.x.into(),
+                        y: b.origin.y.into(),
+                        width: b.size.width.into(),
+                        height: b.size.height.into(),
+                    }
+                }
+            };
+            let workspace_sizes: Vec<f32> = self.workspace_panels
+                .read(cx)
+                .sizes()
+                .iter()
+                .map(|s| s.into())
+                .collect();
+            let mut body_sizes: Vec<f32> = self.body_panels
+                .read(cx)
+                .sizes()
+                .iter()
+                .map(|s| s.into())
+                .collect();
+
+            if self.sftp_panel_minimized {
+                if let Some(prev) = self.prev_monitoring_size {
+                    if body_sizes.len() > 1 {
+                        body_sizes[1] = prev.into();
+                    }
+                }
+            }
+
+            config.set_layout_state(Some(saved_bounds), Some(workspace_sizes), Some(body_sizes));
+            config.set_sidebar_collapsed(self.sidebar_collapsed);
+            config.set_sftp_panel_minimized(self.sftp_panel_minimized);
+            let _ = config.save();
+        } else {
+            tracing::warn!(
+                "[ui] window size is too small ({:?}), skipping save layout state to prevent corrupting saved bounds.",
+                size
+            );
+        }
+    }
 }

src/app/startup.rs

@@ -162,6 +162,12 @@ pub(crate) fn sync_macos_launch_environment() {
                 | "HOMEBREW_PREFIX"
                 | "HOMEBREW_CELLAR"
                 | "HOMEBREW_REPOSITORY"
+                | "HTTP_PROXY"
+                | "HTTPS_PROXY"
+                | "ALL_PROXY"
+                | "http_proxy"
+                | "https_proxy"
+                | "all_proxy"
         ) || key.starts_with("LC_");
 
         if should_import {
@@ -172,12 +178,56 @@ pub(crate) fn sync_macos_launch_environment() {
     }
 }
 
+fn read_proxy_from_env() -> Option<(String, String, Option<u16>, String, String)> {
+    let vars = ["ALL_PROXY", "all_proxy", "HTTPS_PROXY", "https_proxy", "HTTP_PROXY", "http_proxy"];
+    for var in vars {
+        if let Ok(val) = std::env::var(var) {
+            if val.is_empty() {
+                continue;
+            }
+            if let Ok(url) = reqwest::Url::parse(&val) {
+                let scheme = url.scheme();
+                let proxy_type = match scheme {
+                    "socks5" | "socks5h" => "socks5".to_string(),
+                    "http" | "https" => "http".to_string(),
+                    _ => "socks5".to_string(),
+                };
+                let host = url.host_str().unwrap_or("").to_string();
+                let port = url.port();
+                let user = url.username().to_string();
+                let password = url.password().unwrap_or("").to_string();
+                return Some((proxy_type, host, port, user, password));
+            }
+        }
+    }
+    None
+}
+
 #[cfg(not(target_os = "macos"))]
 pub(crate) fn sync_macos_launch_environment() {}
 
 pub(crate) fn open_main_window(cx: &mut App) {
     let config = ConfigStore::load().unwrap_or_else(|_| ConfigStore::in_memory());
 
+    let _ = crate::session::config::ENV_PROXY.get_or_init(|| {
+        read_proxy_from_env().map(|(proxy_type, host, port, user, password)| {
+            tracing::info!(
+                "[proxy] Loaded proxy configuration from environment: type={}, host={}, port={:?}, user={}",
+                proxy_type,
+                host,
+                port,
+                user
+            );
+            crate::session::config::EnvProxy {
+                proxy_type,
+                host,
+                port,
+                user,
+                pass: password,
+            }
+        })
+    });
+
     let mut window_options = WindowOptions::default();
 
     if config.title_bar_style() == crate::session::config::TitleBarStyle::Integrated {
@@ -253,81 +303,14 @@ pub(crate) fn open_main_window(cx: &mut App) {
 
 
 
-        let workspace_panels_clone = view.read(cx).workspace_panels.clone();
-        let body_panels_clone = view.read(cx).body_panels.clone();
         let view_clone = view.clone();
         window.on_window_should_close(cx, move |window: &mut gpui::Window, cx: &mut gpui::App| {
-            if view_clone.read(cx).is_layout_reset {
-                tracing::info!("[ui] layout was reset, skipping save layout state.");
+            let handle = window.window_handle();
+            if !cx.windows().contains(&handle) {
+                tracing::warn!("[ui] window not found in app during close, skipping save layout state.");
                 return true;
             }
-            let current_bounds = window.window_bounds();
-            let bounds = match current_bounds {
-                gpui::WindowBounds::Fullscreen(b) => b,
-                gpui::WindowBounds::Maximized(b) => b,
-                gpui::WindowBounds::Windowed(b) => b,
-            };
-            let size = bounds.size;
-            if size.width.as_f32() > 400.0 && size.height.as_f32() > 300.0 {
-                tracing::info!("[ui] main application window closed, saving layout state...");
-                let mut config = ConfigStore::load().unwrap_or_else(|_| ConfigStore::in_memory());
-                let saved_bounds = match current_bounds {
-                    gpui::WindowBounds::Fullscreen(b) => {
-                        crate::session::config::SavedWindowBounds::Fullscreen {
-                            x: b.origin.x.into(),
-                            y: b.origin.y.into(),
-                            width: b.size.width.into(),
-                            height: b.size.height.into(),
-                        }
-                    }
-                    gpui::WindowBounds::Maximized(b) => {
-                        crate::session::config::SavedWindowBounds::Maximized {
-                            x: b.origin.x.into(),
-                            y: b.origin.y.into(),
-                            width: b.size.width.into(),
-                            height: b.size.height.into(),
-                        }
-                    }
-                    gpui::WindowBounds::Windowed(b) => {
-                        crate::session::config::SavedWindowBounds::Windowed {
-                            x: b.origin.x.into(),
-                            y: b.origin.y.into(),
-                            width: b.size.width.into(),
-                            height: b.size.height.into(),
-                        }
-                    }
-                };
-                let workspace_sizes: Vec<f32> = workspace_panels_clone
-                    .read(cx)
-                    .sizes()
-                    .iter()
-                    .map(|s| s.into())
-                    .collect();
-                let mut body_sizes: Vec<f32> = body_panels_clone
-                    .read(cx)
-                    .sizes()
-                    .iter()
-                    .map(|s| s.into())
-                    .collect();
-
-                if view_clone.read(cx).sftp_panel_minimized {
-                    if let Some(prev) = view_clone.read(cx).prev_monitoring_size {
-                        if body_sizes.len() > 1 {
-                            body_sizes[1] = prev.into();
-                        }
-                    }
-                }
-
-                config.set_layout_state(Some(saved_bounds), Some(workspace_sizes), Some(body_sizes));
-                config.set_sidebar_collapsed(view_clone.read(cx).sidebar_collapsed);
-                config.set_sftp_panel_minimized(view_clone.read(cx).sftp_panel_minimized);
-                let _ = config.save();
-            } else {
-                tracing::warn!(
-                    "[ui] window size is too small ({:?}), skipping save layout state to prevent corrupting saved bounds.",
-                    size
-                );
-            }
+            view_clone.read(cx).save_layout_state(window, cx);
             true
         });
 

src/app/ui.rs

@@ -2,7 +2,7 @@ use gpui::{
     Context, ElementId, Focusable as _, FontWeight, Hsla, InteractiveElement as _, IntoElement,
     MouseButton, MouseDownEvent, ParentElement as _, PathBuilder, Pixels, Render,
     StatefulInteractiveElement as _, Styled as _, Window, canvas, div, hsla, point,
-    prelude::FluentBuilder as _, px, rems, uniform_list,
+    prelude::FluentBuilder as _, px, relative, rems, uniform_list,
 };
 use gpui_component::{
     ActiveTheme, Disableable as _, ElementExt, Icon, IconName, InteractiveElementExt as _, Root,
@@ -1980,52 +1980,109 @@ impl Ashell {
     fn render_window_controls(
         &self,
         window: &mut Window,
-        _cx: &mut Context<Self>,
+        cx: &mut Context<Self>,
     ) -> impl IntoElement {
         let is_macos = cfg!(target_os = "macos");
         let is_fullscreen = window.is_fullscreen();
+        
+        let is_active = cx.active_window() == Some(window.window_handle());
 
         h_flex()
+            .group("window-controls")
             .flex_none()
             .items_center()
             .px_3()
             .gap_2()
             .when(!is_macos || is_fullscreen, |this| {
                 this.child(
-                    div()
+                    h_flex()
                         .id("window-close")
                         .size(px(12.))
                         .rounded_full()
-                        .bg(hsla(0.0, 0.8, 0.4, 1.0)) // Red
-                        .on_click(|_, window, _| window.remove_window())
-                        .hover(|s| s.bg(hsla(0.0, 0.8, 0.5, 1.0)))
-                        .active(|s| s.bg(hsla(0.0, 0.8, 0.3, 1.0))),
+                        .bg(if is_active { hsla(3.0 / 360.0, 1.0, 0.67, 1.0) } else { hsla(0.0, 0.0, 0.8, 1.0) }) // Red or Inactive Grey
+                        .group_hover("window-controls", |s| s.bg(hsla(3.0 / 360.0, 1.0, 0.67, 1.0)))
+                        .when(!is_macos, |this| this.window_control_area(gpui::WindowControlArea::Close))
+                        .on_click(cx.listener(|this, _, window, cx| {
+                            this.save_layout_state(window, cx);
+                            window.remove_window();
+                        }))
+                        .hover(|s| s.bg(hsla(3.0 / 360.0, 1.0, 0.55, 1.0)))
+                        .active(|s| s.bg(hsla(3.0 / 360.0, 1.0, 0.45, 1.0)))
+                        .items_center()
+                        .justify_center()
+                        .child(
+                            h_flex()
+                                .items_center()
+                                .justify_center()
+                                .text_size(px(7.))
+                                .font_weight(FontWeight::BOLD)
+                                .line_height(relative(1.0))
+                                .text_color(hsla(3.0 / 360.0, 1.0, 0.15, 0.7))
+                                .opacity(0.0)
+                                .group_hover("window-controls", |s| s.opacity(1.0))
+                                .child("✕")
+                        ),
                 )
                 .child(
-                    div()
+                    h_flex()
                         .id("window-minimize")
                         .size(px(12.))
                         .rounded_full()
-                        .bg(hsla(0.12, 0.8, 0.4, 1.0)) // Yellow
+                        .bg(if is_active { hsla(39.0 / 360.0, 1.0, 0.59, 1.0) } else { hsla(0.0, 0.0, 0.8, 1.0) }) // Yellow or Inactive Grey
+                        .group_hover("window-controls", |s| s.bg(hsla(39.0 / 360.0, 1.0, 0.59, 1.0)))
+                        .when(!is_macos, |this| this.window_control_area(gpui::WindowControlArea::Min))
                         .on_click(|_, window, _| window.minimize_window())
-                        .hover(|s| s.bg(hsla(0.12, 0.8, 0.5, 1.0)))
-                        .active(|s| s.bg(hsla(0.12, 0.8, 0.3, 1.0))),
+                        .hover(|s| s.bg(hsla(39.0 / 360.0, 1.0, 0.49, 1.0)))
+                        .active(|s| s.bg(hsla(39.0 / 360.0, 1.0, 0.39, 1.0)))
+                        .items_center()
+                        .justify_center()
+                        .child(
+                            h_flex()
+                                .items_center()
+                                .justify_center()
+                                .text_size(px(7.))
+                                .font_weight(FontWeight::BOLD)
+                                .line_height(relative(1.0))
+                                .text_color(hsla(39.0 / 360.0, 1.0, 0.15, 0.8))
+                                .opacity(0.0)
+                                .group_hover("window-controls", |s| s.opacity(1.0))
+                                .child("−")
+                        ),
                 )
                 .child(
-                    div()
+                    h_flex()
                         .id("window-maximize")
                         .size(px(12.))
                         .rounded_full()
-                        .bg(hsla(0.33, 0.8, 0.4, 1.0)) // Green
+                        .bg(if is_active { hsla(127.0 / 360.0, 0.68, 0.47, 1.0) } else { hsla(0.0, 0.0, 0.8, 1.0) }) // Green or Inactive Grey
+                        .group_hover("window-controls", |s| s.bg(hsla(127.0 / 360.0, 0.68, 0.47, 1.0)))
+                        .when(!is_macos, |this| this.window_control_area(gpui::WindowControlArea::Max))
                         .on_click(|_, window, _| {
                             if window.is_fullscreen() {
                                 window.toggle_fullscreen();
                             } else {
+                                #[cfg(target_os = "macos")]
                                 window.titlebar_double_click();
+                                #[cfg(not(target_os = "macos"))]
+                                window.zoom_window();
                             }
                         })
-                        .hover(|s| s.bg(hsla(0.33, 0.8, 0.5, 1.0)))
-                        .active(|s| s.bg(hsla(0.33, 0.8, 0.3, 1.0))),
+                        .hover(|s| s.bg(hsla(127.0 / 360.0, 0.68, 0.37, 1.0)))
+                        .active(|s| s.bg(hsla(127.0 / 360.0, 0.68, 0.27, 1.0)))
+                        .items_center()
+                        .justify_center()
+                        .child(
+                            h_flex()
+                                .items_center()
+                                .justify_center()
+                                .text_size(px(7.))
+                                .font_weight(FontWeight::BOLD)
+                                .line_height(relative(1.0))
+                                .text_color(hsla(127.0 / 360.0, 1.0, 0.15, 0.8))
+                                .opacity(0.0)
+                                .group_hover("window-controls", |s| s.opacity(1.0))
+                                .child("+")
+                        ),
                 )
             })
             .when(is_macos, |this| {
@@ -2308,6 +2365,56 @@ impl Ashell {
                     ));
                 let scrollbar = this.terminal_scrollbars.entry(tab_id.clone()).or_default();
                 el = el.vertical_scrollbar(scrollbar);
+
+                // When disconnected, overlay a reconnect bar at the bottom of the terminal.
+                // Uses absolute positioning so the terminal element itself is unchanged,
+                // keeping panel size stable in multi-panel layouts.
+                let disconnected_reason = this
+                    .tabs
+                    .iter()
+                    .find(|t| t.id == *tab_id)
+                    .and_then(|tab| tab.disconnected_reason.clone());
+                if let Some(reason) = disconnected_reason {
+                    let tab_id_for_reconnect = tab_id.clone();
+                    el = div()
+                        .size_full()
+                        .relative()
+                        .child(el)
+                        .child(
+                            div()
+                                .absolute()
+                                .bottom_0()
+                                .left_0()
+                                .right_0()
+                                .child(
+                                    h_flex()
+                                        .w_full()
+                                        .items_center()
+                                        .gap_2()
+                                        .px_3()
+                                        .py_1()
+                                        .bg(cx.theme().danger.opacity(0.15))
+                                        .child(
+                                            div()
+                                                .text_size(rems(0.85))
+                                                .text_color(cx.theme().danger)
+                                                .child(t!("session_disconnected", "reason" = reason).to_string()),
+                                        )
+                                        .child(
+                                            div()
+                                                .text_size(rems(0.85))
+                                                .text_color(cx.theme().muted_foreground)
+                                                .child(format!("— {}", t!("press_enter_to_reconnect"))),
+                                        )
+                                        .on_mouse_down(
+                                            MouseButton::Left,
+                                            cx.listener(move |this, _, _, cx| {
+                                                this.retry_disconnected_tab(&tab_id_for_reconnect, cx);
+                                            }),
+                                        ),
+                                ),
+                        );
+                }
                 let indicator_color = this
                     .tabs
                     .iter()
@@ -2666,6 +2773,25 @@ impl Render for Ashell {
                     this.close_tab(active_id, cx);
                 }
             }))
+            .on_action(cx.listener(|this, _: &crate::Copy, window, cx| {
+                if let Some(text) = this.active_terminal_selection_text() {
+                    cx.write_to_clipboard(gpui::ClipboardItem::new_string(text));
+                    if let Some(active_id) = &this.active_tab {
+                        if let Some(tab) = this.tabs.iter_mut().find(|tab| &tab.id == active_id) {
+                            tab.clear_selection();
+                        }
+                    }
+                    window.prevent_default();
+                    cx.stop_propagation();
+                }
+            }))
+            .on_action(cx.listener(|this, _: &crate::Paste, window, cx| {
+                if let Some(clipboard) = cx.read_from_clipboard() {
+                    if let Some(text) = clipboard.text() {
+                        this.paste_into_terminal(&text, window, cx);
+                    }
+                }
+            }))
             .when(self.active_title_bar_style == crate::session::config::TitleBarStyle::Integrated, |this| {
                 this.child(
                     div()
@@ -2676,7 +2802,10 @@ impl Render for Ashell {
                         .w_full()
                         .bg(cx.theme().tab_bar)
                         .on_double_click(|_, window, _| {
+                            #[cfg(target_os = "macos")]
                             window.titlebar_double_click();
+                            #[cfg(not(target_os = "macos"))]
+                            window.zoom_window();
                         })
                         .child(self.render_window_controls(window, cx))
                         .child(
@@ -2774,114 +2903,30 @@ impl Render for Ashell {
                         ),
                 )
             })
-            .when_some(self.connection_progress.clone(), |this, progress| {
-                this.child(
-                    div()
-                        .absolute()
-                        .top_0()
-                        .left_0()
-                        .right_0()
-                        .bottom_0()
-                        .bg(Hsla {
-                            h: 0.0,
-                            s: 0.0,
-                            l: 0.0,
-                            a: 0.48,
-                        })
-                        .flex()
-                        .items_center()
-                        .justify_center()
-                        .child(
-                            div()
-                                .w(px(420.))
-                                .p_5()
-                                .rounded_lg()
-                                .border_1()
-                                .border_color(cx.theme().border)
-                                .bg(cx.theme().popover)
-                                .shadow_lg()
-                                .child(
-                                    v_flex()
-                                        .gap_4()
-                                        .child(
-                                            Button::new("ssh-connect-progress")
-                                                .primary()
-                                                .loading(!progress.failed)
-                                                .label(progress.title.clone()),
-                                        )
-                                        .child(
-                                            div()
-                                                .relative()
-                                                .min_h(px(0.))
-                                                .max_h(px(220.))
-                                                .child(
-                                                    div()
-                                                        .id("connection-progress-scroll")
-                                                        .max_h(px(220.))
-                                                        .overflow_hidden()
-                                                        .overflow_y_scroll()
-                                                        .track_scroll(&self.connection_scroll_handle)
-                                                        .child(
-                                                            v_flex().gap_2().children(
-                                                                progress.lines.iter().cloned().map(|line| {
-                                                                    div()
-                                                                        .text_size(rems(1.0))
-                                                                        .text_color(if progress.failed {
-                                                                            cx.theme().danger
-                                                                        } else {
-                                                                            cx.theme().muted_foreground
-                                                                        })
-                                                                        .child(line)
-                                                                }),
-                                                            ),
-                                                        )
-                                                )
-                                                .child(
-                                                    div()
-                                                        .absolute()
-                                                        .top_0()
-                                                        .right_0()
-                                                        .bottom_0()
-                                                        .w(px(16.))
-                                                        .child(
-                                                            Scrollbar::vertical(&self.connection_scroll_handle)
-                                                                .scrollbar_show(ScrollbarShow::Scrolling)
-                                                        )
-                                                )
-                                        )
-                                        .when(progress.failed, |this| {
-                                            this.child(
-                                                h_flex()
-                                                    .justify_end()
-                                                    .gap_2()
-                                                    .child(
-                                                        Button::new("ssh-connect-progress-retry")
-                                                            .primary()
-                                                            .label(t!("retry").to_string())
-                                                            .on_click(cx.listener(
-                                                                |this, _, _, cx| {
-                                                                    this.retry_connection_progress(
-                                                                        cx,
-                                                                    )
-                                                                },
-                                                            )),
-                                                    )
-                                                    .child(
-                                                        Button::new("ssh-connect-progress-close")
-                                                            .label(t!("cancel").to_string())
-                                                            .on_click(cx.listener(
-                                                                |this, _, _, cx| {
-                                                                    this.cancel_connection_progress(
-                                                                        cx,
-                                                                    )
-                                                                },
-                                                            )),
-                                                    ),
-                                            )
-                                        }),
-                                ),
-                        ),
-                )
+            .on_prepaint({
+                let view = cx.entity().clone();
+                move |_, window, cx| {
+                    view.update(cx, |this, cx| {
+                        let current_win_size = window.viewport_size();
+                        let size_changed = this.last_window_size.map_or(true, |prev| prev != current_win_size);
+                        this.last_window_size = Some(current_win_size);
+
+                        let current_sizes = this.workspace_panels.read(cx).sizes().clone();
+                        if let Some(current_first_size) = current_sizes.first().copied() {
+                            if size_changed {
+                                if let Some(target_width) = this.last_sidebar_width {
+                                    if current_first_size != target_width {
+                                        this.workspace_panels.update(cx, |state, cx| {
+                                            state.resize_panel(0, target_width, window, cx);
+                                        });
+                                    }
+                                }
+                            } else {
+                                this.last_sidebar_width = Some(current_first_size);
+                            }
+                        }
+                    });
+                }
             })
     }
 }

src/backend/ssh.rs

@@ -255,8 +255,8 @@ async fn connect_and_authenticate(
 ) -> Result<russh::client::Handle<ClientHandler>> {
     let config = Arc::new(client::Config {
         inactivity_timeout: Some(std::time::Duration::from_secs(600)),
-        keepalive_interval: Some(std::time::Duration::from_secs(10)),
-        keepalive_max: 3,
+        keepalive_interval: Some(std::time::Duration::from_secs(3)),
+        keepalive_max: 2,
         ..Default::default()
     });
     let addr = format!("{}:{}", session.host, session.port);
@@ -265,11 +265,18 @@ async fn connect_and_authenticate(
         addr,
         session.user
     );
+    let status_text = if let Some((ptype, phost, pport)) = crate::session::config::active_proxy(session) {
+        let pport_val = pport.unwrap_or_else(|| if ptype == "http" { 8080 } else { 1080 });
+        format!("connecting to {addr} via {} proxy {}:{}", ptype.to_uppercase(), phost, pport_val)
+    } else {
+        format!("opening tcp connection to {addr}")
+    };
     let _ = events.send(BackendEvent::Status {
         tab_id: tab_id.to_string(),
-        text: format!("opening tcp connection to {addr}"),
+        text: status_text,
     });
-    let mut handle = client::connect(config, addr.as_str(), ClientHandler)
+    let stream = crate::session::config::connect_proxy(session).await?;
+    let mut handle = client::connect_stream(config, stream, ClientHandler)
         .await
         .with_context(|| format!("connect {addr} failed"))?;
 

src/main.rs

@@ -18,11 +18,11 @@ gpui::actions!(ashell_terminal, [TerminalTabKey, TerminalBacktabKey]);
 pub(crate) use app::keybinding_recorder::{
     ClosePane, FocusPaneDown, FocusPaneLeft, FocusPaneRight, FocusPaneUp, NewSsh, OpenSearch,
     OpenSession, OpenSettings, OpenTransfers, SplitPaneDown, SplitPaneLeft, SplitPaneRight,
-    SplitPaneUp, ToggleSftpZoom, ToggleSidebar,
+    SplitPaneUp, ToggleSftpZoom, ToggleSidebar, Copy, Paste,
 };
 
 pub(crate) use app::{
-    Ashell, ConnectionProgress, PaneLayout, SelectorEntry, SftpContextMenuState, TabGroup,
+    Ashell, PaneLayout, SelectorEntry, SftpContextMenuState, TabGroup,
 };
 
 fn main() {

src/session/config.rs

@@ -31,6 +31,16 @@ pub struct Session {
     pub passphrase: String,
     #[serde(default)]
     pub last_used: Option<String>,
+    #[serde(default)]
+    pub proxy_type: String, // "none", "socks5", "http"
+    #[serde(default)]
+    pub proxy_host: String,
+    #[serde(default)]
+    pub proxy_port: Option<u16>,
+    #[serde(default)]
+    pub proxy_user: String,
+    #[serde(default)]
+    pub proxy_password: String,
 }
 
 impl Session {
@@ -48,6 +58,11 @@ impl Session {
             private_key_inline: String::new(),
             passphrase: String::new(),
             last_used: None,
+            proxy_type: "none".to_string(),
+            proxy_host: String::new(),
+            proxy_port: None,
+            proxy_user: String::new(),
+            proxy_password: String::new(),
         }
     }
 
@@ -72,6 +87,11 @@ impl Session {
             private_key_inline,
             passphrase,
             last_used: None,
+            proxy_type: "none".to_string(),
+            proxy_host: String::new(),
+            proxy_port: None,
+            proxy_user: String::new(),
+            proxy_password: String::new(),
         }
     }
 
@@ -93,6 +113,11 @@ impl Session {
             private_key_inline: String::new(),
             passphrase: String::new(),
             last_used: None,
+            proxy_type: "none".to_string(),
+            proxy_host: String::new(),
+            proxy_port: None,
+            proxy_user: String::new(),
+            proxy_password: String::new(),
         }
     }
 }
@@ -128,6 +153,16 @@ pub enum TitleBarStyle {
     Integrated,
 }
 
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
+#[serde(rename_all = "kebab-case")]
+pub enum CursorStyle {
+    #[default]
+    Default,
+    Blink,
+    Beam,
+    BeamBlink,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ConfigFile {
     #[serde(default = "default_follow_system_theme")]
@@ -155,6 +190,8 @@ pub struct ConfigFile {
     #[serde(default)]
     pub title_bar_style: TitleBarStyle,
     #[serde(default)]
+    pub cursor_style: CursorStyle,
+    #[serde(default)]
     pub sessions: Vec<Session>,
     #[serde(default)]
     pub window_bounds: Option<SavedWindowBounds>,
@@ -194,6 +231,28 @@ pub struct ConfigFile {
     pub sync_s3_bucket: String,
     #[serde(default = "default_s3_object_key")]
     pub sync_s3_object_key: String,
+    #[serde(default)]
+    pub use_proxy: bool,
+    #[serde(default = "default_read_env_proxy")]
+    pub read_env_proxy: bool,
+    #[serde(default = "default_global_proxy_type")]
+    pub global_proxy_type: String,
+    #[serde(default)]
+    pub global_proxy_host: String,
+    #[serde(default)]
+    pub global_proxy_port: Option<u16>,
+    #[serde(default)]
+    pub global_proxy_user: String,
+    #[serde(default)]
+    pub global_proxy_password: String,
+}
+
+fn default_read_env_proxy() -> bool {
+    true
+}
+
+fn default_global_proxy_type() -> String {
+    "socks5".to_string()
 }
 
 fn default_monitoring_position() -> String {
@@ -249,6 +308,7 @@ impl Default for ConfigFile {
             ui_font_family: default_ui_font_family(),
             terminal_font_family: default_terminal_font_family(),
             title_bar_style: TitleBarStyle::default(),
+            cursor_style: CursorStyle::default(),
             sessions: Vec::new(),
             window_bounds: None,
             workspace_panels: None,
@@ -269,6 +329,13 @@ impl Default for ConfigFile {
             sync_s3_region: default_s3_region(),
             sync_s3_bucket: String::new(),
             sync_s3_object_key: default_s3_object_key(),
+            use_proxy: false,
+            read_env_proxy: true,
+            global_proxy_type: default_global_proxy_type(),
+            global_proxy_host: String::new(),
+            global_proxy_port: None,
+            global_proxy_user: String::new(),
+            global_proxy_password: String::new(),
         }
     }
 }
@@ -603,6 +670,57 @@ impl ConfigStore {
         self.cache.title_bar_style = style;
     }
 
+    pub fn cursor_style(&self) -> CursorStyle {
+        self.cache.cursor_style
+    }
+
+    pub fn set_cursor_style(&mut self, style: CursorStyle) {
+        self.cache.cursor_style = style;
+    }
+
+    pub fn use_proxy(&self) -> bool {
+        self.cache.use_proxy
+    }
+    pub fn set_use_proxy(&mut self, val: bool) {
+        self.cache.use_proxy = val;
+    }
+    pub fn read_env_proxy(&self) -> bool {
+        self.cache.read_env_proxy
+    }
+    pub fn set_read_env_proxy(&mut self, val: bool) {
+        self.cache.read_env_proxy = val;
+    }
+    pub fn global_proxy_type(&self) -> &str {
+        &self.cache.global_proxy_type
+    }
+    pub fn set_global_proxy_type(&mut self, val: String) {
+        self.cache.global_proxy_type = val;
+    }
+    pub fn global_proxy_host(&self) -> &str {
+        &self.cache.global_proxy_host
+    }
+    pub fn set_global_proxy_host(&mut self, val: String) {
+        self.cache.global_proxy_host = val;
+    }
+    pub fn global_proxy_port(&self) -> Option<u16> {
+        self.cache.global_proxy_port
+    }
+    pub fn set_global_proxy_port(&mut self, val: Option<u16>) {
+        self.cache.global_proxy_port = val;
+    }
+    pub fn global_proxy_user(&self) -> &str {
+        &self.cache.global_proxy_user
+    }
+    pub fn set_global_proxy_user(&mut self, val: String) {
+        self.cache.global_proxy_user = val;
+    }
+    pub fn global_proxy_password(&self) -> &str {
+        &self.cache.global_proxy_password
+    }
+    pub fn set_global_proxy_password(&mut self, val: String) {
+        self.cache.global_proxy_password = val;
+    }
+
     pub fn show_hidden_files(&self) -> bool {
         self.cache.show_hidden_files
     }
@@ -663,3 +781,166 @@ impl ConfigStore {
         Ok(())
     }
 }
+
+pub trait ProxyStream: tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin + Send + Sync + 'static {}
+impl<T: tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin + Send + Sync + 'static> ProxyStream for T {}
+
+use std::sync::OnceLock;
+
+#[derive(Debug, Clone)]
+pub struct EnvProxy {
+    pub proxy_type: String,
+    pub host: String,
+    pub port: Option<u16>,
+    pub user: String,
+    pub pass: String,
+}
+
+pub static ENV_PROXY: OnceLock<Option<EnvProxy>> = OnceLock::new();
+
+pub async fn connect_proxy(session: &Session) -> Result<Box<dyn ProxyStream>> {
+    let target_host = &session.host;
+    let target_port = session.port;
+
+    let config = ConfigStore::load().unwrap_or_else(|_| ConfigStore::in_memory());
+    let (proxy_type, proxy_host, proxy_port, proxy_user, proxy_password) = {
+        if !session.proxy_type.is_empty() && session.proxy_type != "none" {
+            (
+                session.proxy_type.clone(),
+                session.proxy_host.clone(),
+                session.proxy_port,
+                session.proxy_user.clone(),
+                session.proxy_password.clone(),
+            )
+        } else if config.cache.read_env_proxy && ENV_PROXY.get().and_then(|opt| opt.as_ref()).is_some() {
+            let env_p = ENV_PROXY.get().and_then(|opt| opt.as_ref()).unwrap();
+            (
+                env_p.proxy_type.clone(),
+                env_p.host.clone(),
+                env_p.port,
+                env_p.user.clone(),
+                env_p.pass.clone(),
+            )
+        } else if config.cache.use_proxy {
+            (
+                config.cache.global_proxy_type.clone(),
+                config.cache.global_proxy_host.clone(),
+                config.cache.global_proxy_port,
+                config.cache.global_proxy_user.clone(),
+                config.cache.global_proxy_password.clone(),
+            )
+        } else {
+            ("none".to_string(), String::new(), None, String::new(), String::new())
+        }
+    };
+    
+    if proxy_type != "none" && (proxy_host.is_empty() || proxy_port.is_none()) {
+        let addr = format!("{}:{}", target_host, target_port);
+        let stream = tokio::net::TcpStream::connect(&addr).await?;
+        return Ok(Box::new(stream));
+    }
+
+    match proxy_type.as_str() {
+        "socks5" | "socks5h" => {
+            let proxy_port = proxy_port.unwrap_or(1080);
+            let proxy_addr = format!("{}:{}", proxy_host, proxy_port);
+
+            if !proxy_user.is_empty() {
+                let stream = tokio_socks::tcp::Socks5Stream::connect_with_password(
+                    proxy_addr.as_str(),
+                    (target_host.as_str(), target_port),
+                    &proxy_user,
+                    &proxy_password,
+                )
+                .await
+                .map_err(|e| anyhow::anyhow!("SOCKS5 proxy connection failed: {}", e))?;
+                Ok(Box::new(stream))
+            } else {
+                let stream = tokio_socks::tcp::Socks5Stream::connect(
+                    proxy_addr.as_str(),
+                    (target_host.as_str(), target_port),
+                )
+                .await
+                .map_err(|e| anyhow::anyhow!("SOCKS5 proxy connection failed: {}", e))?;
+                Ok(Box::new(stream))
+            }
+        }
+        "http" => {
+            let proxy_port = proxy_port.unwrap_or(8080);
+            let proxy_addr = format!("{}:{}", proxy_host, proxy_port);
+
+            use tokio::io::AsyncWriteExt;
+            let mut stream = tokio::net::TcpStream::connect(&proxy_addr)
+                .await
+                .map_err(|e| anyhow::anyhow!("HTTP proxy connection failed: {}", e))?;
+
+            let mut request = format!(
+                "CONNECT {}:{} HTTP/1.1\r\nHost: {}:{}\r\n",
+                target_host, target_port, target_host, target_port
+            );
+            if !proxy_user.is_empty() {
+                use base64::Engine as _;
+                let auth = format!("{}:{}", proxy_user, proxy_password);
+                let encoded = base64::engine::general_purpose::STANDARD.encode(auth);
+                request.push_str(&format!("Proxy-Authorization: Basic {}\r\n", encoded));
+            }
+            request.push_str("\r\n");
+
+            stream.write_all(request.as_bytes()).await?;
+
+            let mut response = [0u8; 1024];
+            let n = tokio::io::AsyncReadExt::read(&mut stream, &mut response).await?;
+            let resp_str = String::from_utf8_lossy(&response[..n]);
+            if !resp_str.contains("200") && !resp_str.contains("established") {
+                return Err(anyhow::anyhow!("HTTP proxy CONNECT failed: {}", resp_str));
+            }
+
+            Ok(Box::new(stream))
+        }
+        _ => {
+            let addr = format!("{}:{}", target_host, target_port);
+            let stream = tokio::net::TcpStream::connect(&addr).await?;
+            Ok(Box::new(stream))
+        }
+    }
+}
+
+pub fn active_proxy(session: &Session) -> Option<(String, String, Option<u16>)> {
+    let config = ConfigStore::load().unwrap_or_else(|_| ConfigStore::in_memory());
+    let (proxy_type, proxy_host, proxy_port, _, _) = {
+        if !session.proxy_type.is_empty() && session.proxy_type != "none" {
+            (
+                session.proxy_type.clone(),
+                session.proxy_host.clone(),
+                session.proxy_port,
+                session.proxy_user.clone(),
+                session.proxy_password.clone(),
+            )
+        } else if config.cache.read_env_proxy && ENV_PROXY.get().and_then(|opt| opt.as_ref()).is_some() {
+            let env_p = ENV_PROXY.get().and_then(|opt| opt.as_ref()).unwrap();
+            (
+                env_p.proxy_type.clone(),
+                env_p.host.clone(),
+                env_p.port,
+                env_p.user.clone(),
+                env_p.pass.clone(),
+            )
+        } else if config.cache.use_proxy {
+            (
+                config.cache.global_proxy_type.clone(),
+                config.cache.global_proxy_host.clone(),
+                config.cache.global_proxy_port,
+                config.cache.global_proxy_user.clone(),
+                config.cache.global_proxy_password.clone(),
+            )
+        } else {
+            ("none".to_string(), String::new(), None, String::new(), String::new())
+        }
+    };
+    
+    if proxy_type != "none" && !proxy_host.is_empty() && proxy_port.is_some() {
+        Some((proxy_type, proxy_host, proxy_port))
+    } else {
+        None
+    }
+}

src/session/mod.rs

@@ -11,7 +11,7 @@ use uuid::Uuid;
 use self::config::{AuthMethod, Session};
 
 use crate::{
-    Ashell, ConnectionProgress, PaneLayout, SelectorEntry, TabGroup,
+    Ashell, PaneLayout, SelectorEntry, TabGroup,
     app::constants::{
         DEFAULT_COLS, DEFAULT_ROWS, SIDEBAR_WIDTH, TAB_BAR_HEIGHT, TERMINAL_PADDING_X,
         TERMINAL_PADDING_Y,
@@ -79,6 +79,17 @@ impl Ashell {
             return;
         }
 
+        if self.ssh_proxy_type != "none" {
+            let proxy_host = self.proxy_host_input.read(cx).value().trim().to_string();
+            let proxy_port_str = self.proxy_port_input.read(cx).value().trim().to_string();
+            let proxy_port = proxy_port_str.parse::<u16>().ok();
+            if proxy_host.is_empty() || proxy_port.is_none() {
+                self.status = "Proxy host and port are required".into();
+                cx.notify();
+                return;
+            }
+        }
+
         let name = if session_name.is_empty() {
             host.clone()
         } else {
@@ -107,6 +118,17 @@ impl Ashell {
             session.id = id;
         }
         session.last_used = existing_last_used;
+        session.proxy_type = self.ssh_proxy_type.clone();
+        session.proxy_host = self.proxy_host_input.read(cx).value().trim().to_string();
+        session.proxy_port = self
+            .proxy_port_input
+            .read(cx)
+            .value()
+            .trim()
+            .parse::<u16>()
+            .ok();
+        session.proxy_user = self.proxy_user_input.read(cx).value().trim().to_string();
+        session.proxy_password = self.proxy_password_input.read(cx).value().to_string();
         self.config.upsert(session.clone());
         if let Err(err) = self.config.save() {
             tracing::warn!("failed to save config: {err:#}");
@@ -139,6 +161,11 @@ impl Ashell {
         Self::set_input_value(&self.key_path_input, "", window, cx);
         Self::set_input_value(&self.key_inline_input, "", window, cx);
         Self::set_input_value(&self.passphrase_input, "", window, cx);
+        self.ssh_proxy_type = "none".to_string();
+        Self::set_input_value(&self.proxy_host_input, "", window, cx);
+        Self::set_input_value(&self.proxy_port_input, "", window, cx);
+        Self::set_input_value(&self.proxy_user_input, "", window, cx);
+        Self::set_input_value(&self.proxy_password_input, "", window, cx);
     }
 
     pub(crate) fn load_session_into_form(
@@ -172,6 +199,16 @@ impl Ashell {
             window,
             cx,
         );
+        self.ssh_proxy_type = session.proxy_type.clone();
+        Self::set_input_value(&self.proxy_host_input, session.proxy_host.clone(), window, cx);
+        Self::set_input_value(
+            &self.proxy_port_input,
+            session.proxy_port.map(|p| p.to_string()).unwrap_or_default(),
+            window,
+            cx,
+        );
+        Self::set_input_value(&self.proxy_user_input, session.proxy_user.clone(), window, cx);
+        Self::set_input_value(&self.proxy_password_input, session.proxy_password.clone(), window, cx);
     }
 
     pub(crate) fn pick_ssh_key_path(&mut self, window: &mut Window, cx: &mut Context<Self>) {
@@ -297,6 +334,19 @@ impl Ashell {
         cx.notify();
     }
 
+    pub(crate) fn change_cursor_style(
+        &mut self,
+        style: crate::session::config::CursorStyle,
+        cx: &mut Context<Self>,
+    ) {
+        self.cursor_style = style;
+        self.config.set_cursor_style(style);
+        if let Err(err) = self.config.save() {
+            tracing::warn!("failed to save cursor style: {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();
@@ -313,6 +363,11 @@ impl Ashell {
         cx.notify();
     }
 
+    pub(crate) fn set_ssh_proxy_type(&mut self, proxy_type: String, cx: &mut Context<Self>) {
+        self.ssh_proxy_type = proxy_type;
+        cx.notify();
+    }
+
     pub(crate) fn connect_saved_session(&mut self, session_id: String, cx: &mut Context<Self>) {
         tracing::info!(
             "[ui] user clicked to connect saved session '{}'",
@@ -478,12 +533,6 @@ impl Ashell {
         self.sftp_handles.insert(group_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();
     }
@@ -497,57 +546,57 @@ impl Ashell {
         cx.notify();
     }
 
-    pub(crate) fn retry_connection_progress(&mut self, cx: &mut Context<Self>) {
-        let Some(progress) = self.connection_progress.clone() else {
+    /// Retry a single disconnected tab by its ID.
+    /// For SSH tabs: spawns a new SSH connection and restarts SFTP.
+    /// For local tabs: spawns a new local shell.
+    ///
+    /// The existing `TerminalTab` (including its `term` scrollback history)
+    /// is preserved — only the backend is swapped via `set_backend()`.
+    pub(crate) fn retry_disconnected_tab(&mut self, tab_id: &str, cx: &mut Context<Self>) {
+        let Some(ix) = self.tabs.iter().position(|t| t.id == tab_id) else {
             return;
         };
-        self.connection_progress = None;
-        let mut groups_to_restart_sftp = std::collections::HashSet::new();
-
-        let mut retry_tabs = Vec::new();
-        for (ix, tab) in self.tabs.iter().enumerate() {
-            if !tab.connected && tab.session.is_some() {
-                retry_tabs.push((ix, tab.id.clone(), tab.session.clone().unwrap()));
-            }
-        }
-
-        if retry_tabs.is_empty() {
-            cx.notify();
+        if self.tabs[ix].connected || self.tabs[ix].disconnected_reason.is_none() {
             return;
         }
 
-        for (ix, tab_id, session) in retry_tabs {
-            // Close old backend
-            self.tabs[ix].backend.send(BackendCommand::Close);
+        let is_ssh = self.tabs[ix].session.is_some();
+        let session = self.tabs[ix].session.clone();
+        let new_generation = self.tabs[ix].backend_generation + 1;
+        let cols = self.tabs[ix].cols;
+        let rows = self.tabs[ix].rows;
 
-            // Spawn new backend
+        // Close old backend (sends Close through the shared Arc<Mutex>)
+        self.tabs[ix].send_backend(BackendCommand::Close);
+
+        if let Some(session) = session {
+            // SSH tab: spawn new SSH connection
             let backend = ssh::spawn_ssh_terminal(
                 self.runtime.handle(),
-                tab_id.clone(),
+                tab_id.to_string(),
                 session.clone(),
-                DEFAULT_COLS,
-                DEFAULT_ROWS,
+                cols,
+                rows,
                 self.events_tx.clone(),
             );
 
-            // Replace tab state in-place to reuse the UI component
-            self.tabs[ix] =
-                TerminalTab::new_ssh(tab_id.clone(), &session, backend, self.events_tx.clone());
+            // Swap the backend — the Term's internal listener shares the
+            // same Arc<Mutex<BackendTx>>, so user input is automatically
+            // routed to the new backend. Terminal history is preserved.
+            self.tabs[ix].set_backend(backend);
+            self.tabs[ix].connected = false;
+            self.tabs[ix].status = "connecting".into();
+            self.tabs[ix].disconnected_reason = None;
+            self.tabs[ix].backend_generation = new_generation;
+            self.tabs[ix].backend_initialized = false;
 
-            // Find group to restart SFTP
+            // Restart SFTP for the group containing this tab
             if let Some(group) = self
                 .tab_groups
                 .iter()
-                .find(|g| g.pane_root.contains(&tab_id))
+                .find(|g| g.pane_root.contains(tab_id))
             {
-                groups_to_restart_sftp.insert(group.id.clone());
-            }
-        }
-
-        // Restart SFTP for affected groups
-        for group_id in groups_to_restart_sftp {
-            if let Some(group) = self.tab_groups.iter_mut().find(|g| g.id == group_id) {
-                // Use the session of any tab in that group
+                let group_id = group.id.clone();
                 let group_session = self
                     .tabs
                     .iter()
@@ -555,48 +604,57 @@ impl Ashell {
                     .and_then(|t| t.session.clone());
 
                 if let Some(session) = group_session {
-                    if let Some(old_handle) = self.sftp_handles.remove(&group.id) {
+                    if let Some(old_handle) = self.sftp_handles.remove(&group_id) {
                         old_handle.close();
                     }
                     let sftp_handle = crate::sftp::spawn_sftp(
                         self.runtime.handle(),
-                        group.id.clone(),
+                        group_id.clone(),
                         session,
                         self.events_tx.clone(),
                     );
-                    self.sftp_handles.insert(group.id.clone(), sftp_handle);
+                    self.sftp_handles.insert(group_id.clone(), sftp_handle);
 
-                    if let Some(sftp) = group.sftp.as_mut() {
-                        sftp.status = rust_i18n::t!("sftp_connecting").to_string();
+                    if let Some(group) = self.tab_groups.iter_mut().find(|g| g.id == group_id) {
+                        if let Some(sftp) = group.sftp.as_mut() {
+                            sftp.status = rust_i18n::t!("sftp_connecting").to_string();
+                        }
                     }
                 }
             }
+        } else {
+            // Local tab: spawn new local shell
+            match local::spawn_local_terminal(
+                tab_id.to_string(),
+                cols,
+                rows,
+                self.events_tx.clone(),
+            ) {
+                Ok(backend) => {
+                    // Swap the backend — preserves terminal history.
+                    self.tabs[ix].set_backend(backend);
+                    self.tabs[ix].connected = true;
+                    self.tabs[ix].status = "local shell".into();
+                    self.tabs[ix].disconnected_reason = None;
+                    self.tabs[ix].backend_generation = new_generation;
+                    self.tabs[ix].backend_initialized = false;
+                    // Resize the new PTY to match the pane dimensions.
+                    self.tabs[ix].send_backend(BackendCommand::Resize { cols, rows });
+                }
+                Err(err) => {
+                    self.status = format!("failed to reopen local terminal: {err:#}").into();
+                    cx.notify();
+                    return;
+                }
+            }
         }
 
-        self.connection_progress = Some(ConnectionProgress {
-            tab_id: progress.tab_id.clone(),
-            title: t!("connecting").into(),
-            lines: vec![t!("starting_connection").into()],
-            failed: false,
-        });
-        self.status = "ssh tabs retrying".into();
-        cx.notify();
-    }
-
-    pub(crate) fn cancel_connection_progress(&mut self, cx: &mut Context<Self>) {
-        if self.connection_progress.is_none() {
-            return;
-        }
-        self.connection_progress = None;
-        let tabs_to_close: Vec<_> = self
-            .tabs
-            .iter()
-            .filter(|tab| !tab.connected && tab.session.is_some())
-            .map(|tab| tab.id.clone())
-            .collect();
-        for id in tabs_to_close {
-            self.handle_tab_close(id);
+        self.status = if is_ssh {
+            "ssh tab retrying"
+        } else {
+            "local tab reopened"
         }
+        .into();
         cx.notify();
     }
 
@@ -660,7 +718,7 @@ impl Ashell {
                 id
             );
             if let Some(ix) = self.tabs.iter().position(|tab| tab.id == id) {
-                self.tabs[ix].backend.send(BackendCommand::Close);
+                self.tabs[ix].send_backend(BackendCommand::Close);
                 self.tabs.remove(ix);
             }
             return;
@@ -719,7 +777,7 @@ impl Ashell {
                 .collect();
             for tab_id in &tab_ids {
                 if let Some(ix) = self.tabs.iter().position(|tab| tab.id == *tab_id) {
-                    self.tabs[ix].backend.send(BackendCommand::Close);
+                    self.tabs[ix].send_backend(BackendCommand::Close);
                     self.tabs.retain(|t| t.id != *tab_id);
                 }
             }
@@ -731,7 +789,7 @@ impl Ashell {
         } else {
             // Just remove this tab from the group
             if let Some(ix) = self.tabs.iter().position(|tab| tab.id == id) {
-                self.tabs[ix].backend.send(BackendCommand::Close);
+                self.tabs[ix].send_backend(BackendCommand::Close);
                 self.tabs.retain(|t| t.id != id);
             }
             if let Some(g) = self
@@ -832,6 +890,18 @@ impl Ashell {
             }
         }
         if event.button == MouseButton::Left {
+            if self.config.right_click_copy_paste() {
+                if let Some(text) = self.active_terminal_selection_text() {
+                    if !text.is_empty() {
+                        cx.write_to_clipboard(gpui::ClipboardItem::new_string(text));
+                        if let Some(active_id) = &self.active_tab {
+                            if let Some(tab) = self.tabs.iter_mut().find(|tab| &tab.id == active_id) {
+                                tab.clear_selection();
+                            }
+                        }
+                    }
+                }
+            }
             self.begin_terminal_selection(event, cx);
         }
         cx.notify();

src/sftp/mod.rs

@@ -218,9 +218,13 @@ pub fn spawn_sftp(
         .await
         {
             let _ = events.send(BackendEvent::SftpStatus {
-                tab_id,
+                tab_id: tab_id.clone(),
                 text: format!("sftp error: {err:#}"),
             });
+            let _ = events.send(BackendEvent::Closed {
+                tab_id,
+                reason: format!("sftp error: {err:#}"),
+            });
         }
     });
     SftpHandle {
@@ -824,10 +828,13 @@ async fn connect_and_authenticate(
 ) -> Result<Arc<russh::client::Handle<SftpClientHandler>>> {
     let config = Arc::new(client::Config {
         inactivity_timeout: Some(std::time::Duration::from_secs(600)),
+        keepalive_interval: Some(std::time::Duration::from_secs(3)),
+        keepalive_max: 2,
         ..Default::default()
     });
     let addr = format!("{}:{}", session.host, session.port);
-    let mut handle = client::connect(config, addr.as_str(), SftpClientHandler)
+    let stream = crate::session::config::connect_proxy(session).await?;
+    let mut handle = client::connect_stream(config, stream, SftpClientHandler)
         .await
         .with_context(|| format!("connect {addr} failed"))?;
 

src/terminal/custom_blocks.rs

@@ -335,5 +335,3 @@ pub fn paint_custom_block(
 
     painted
 }
-
-

src/terminal/element.rs

@@ -464,11 +464,35 @@ impl TerminalElement {
     }
 
     fn cursor_layout(&self, cx: &App) -> Option<CursorLayout> {
-        self.snapshot.cursor.map(|cursor| CursorLayout {
-            row: cursor.row,
-            col: cursor.col,
-            shape: cursor.shape,
-            color: cx.theme().primary,
+        use crate::session::config::CursorStyle;
+        let cursor_style = self.view.read(cx).cursor_style;
+        let show_cursor = match cursor_style {
+            CursorStyle::Blink | CursorStyle::BeamBlink => {
+                if let Ok(duration) = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH) {
+                    (duration.as_millis() / 600) % 2 == 0
+                } else {
+                    true
+                }
+            }
+            _ => true,
+        };
+
+        self.snapshot.cursor.map(|cursor| {
+            let mut shape = match cursor_style {
+                CursorStyle::Default => cursor.shape,
+                CursorStyle::Blink => CursorShape::Block,
+                CursorStyle::Beam => CursorShape::Beam,
+                CursorStyle::BeamBlink => CursorShape::Beam,
+            };
+            if !show_cursor {
+                shape = CursorShape::Hidden;
+            }
+            CursorLayout {
+                row: cursor.row,
+                col: cursor.col,
+                shape,
+                color: cx.theme().primary,
+            }
         })
     }
 }

src/terminal/highlight.rs

@@ -32,15 +32,59 @@ impl HslaExt for Hsla {
 
 #[derive(Debug, Clone)]
 struct HighlightColors {
-    error: Hsla,
-    success: Hsla,
-    warning: Hsla,
-    info: Hsla,
-    failure: Hsla,
-    network: Hsla,
-    url: Hsla,
-    port: Hsla,
-    debug: Hsla,
+    // Log levels
+    error: Hsla,       // ERROR, ERR
+    critical: Hsla,    // PANIC, FATAL, EMERGENCY, CRITICAL
+    warning: Hsla,     // WARNING, WARN
+    info: Hsla,        // INFO, NOTICE
+    debug: Hsla,       // DEBUG, TRACE, DBG
+    alert: Hsla,       // ALERT
+
+    // Status indicators
+    success: Hsla,     // SUCCESS, OK, PASS, DONE, COMPLETED
+    failure: Hsla,     // FAILED, FAIL, FAILURE
+    pending: Hsla,     // PENDING, WAITING, PROCESSING
+    running: Hsla,     // RUNNING, ACTIVE, EXECUTING
+    stopped: Hsla,     // STOPPED, INACTIVE, HALTED, IDLE
+    skipped: Hsla,     // SKIPPED, SKIP
+
+    // Network
+    network_up: Hsla,      // UP, ONLINE, CONNECTED
+    network_down: Hsla,    // DOWN, OFFLINE, UNREACHABLE
+    timeout: Hsla,         // TIMEOUT, TIMED OUT
+    refused: Hsla,         // REFUSED, REJECTED, DENIED
+
+    // Security & Auth
+    security: Hsla,    // SSH, SSL, TLS, CERTIFICATE
+    auth: Hsla,        // AUTHENTICATED, AUTHORIZED, LOGIN
+    danger: Hsla,      // ROOT, SUDO, PASSWORD, SECRET
+
+    // Operations
+    started: Hsla,     // START, BOOT, STARTING
+    stopped_op: Hsla,  // STOP, SHUTDOWN, STOPPING
+    restart: Hsla,     // RESTART, RESTARTING
+    deploy: Hsla,      // DEPLOY, DEPLOYED, DEPLOYMENT
+    crashed: Hsla,     // CRASH, CRASHED, SIGSEGV
+
+    // Resources
+    memory: Hsla,      // MEMORY, RAM, SWAP, HEAP
+    cpu: Hsla,         // CPU, PROCESSOR, CORE
+    disk: Hsla,        // DISK, STORAGE, PARTITION, MOUNT
+
+    // HTTP codes
+    http_2xx: Hsla,    // 200-299 Success
+    http_3xx: Hsla,    // 300-399 Redirect
+    http_4xx: Hsla,    // 400-499 Client Error
+    http_5xx: Hsla,    // 500-599 Server Error
+
+    // Dev / Exceptions
+    exception: Hsla,   // Exception, Traceback, Error type
+    deprecated: Hsla,  // DEPRECATED, TODO, FIXME
+
+    // Existing
+    network: Hsla,     // IP addresses
+    url: Hsla,         // http://, https://
+    port: Hsla,        // :22, :443, etc.
 }
 
 fn hsla(r: u8, g: u8, b: u8) -> Hsla {
@@ -55,20 +99,154 @@ fn hsla(r: u8, g: u8, b: u8) -> Hsla {
 
 fn highlight_colors() -> HighlightColors {
     HighlightColors {
-        error:   hsla(224,  96,  96), // #E06060 red
-        success: hsla(126, 198, 153), // #7EC699 green
-        warning: hsla(232, 201, 122), // #E8C97A yellow
-        info:    hsla(108, 180, 238), // #6CB4EE blue
-        failure: hsla(232, 168, 124), // #E8A87C orange
-        network: hsla(199, 146, 234), // #C792EA purple
-        url:     hsla( 86, 212, 199), // #56D4C7 teal
-        port:    hsla(130, 170, 200), // #82AAC8 muted teal
-        debug:   hsla(130, 140, 155), // #828C9B gray
+        // Log levels
+        error:      hsla(224,  96,  96), // #E06060 red
+        critical:   hsla(255,  50,  50), // #FF3232 bright red
+        warning:    hsla(232, 201, 122), // #E8C97A yellow
+        info:       hsla(108, 180, 238), // #6CB4EE blue
+        debug:      hsla(130, 140, 155), // #828C9B gray
+        alert:      hsla(213, 126, 234), // #D57EEA bright magenta
+
+        // Status
+        success:    hsla(126, 198, 153), // #7EC699 green
+        failure:    hsla(232, 168, 124), // #E8A87C orange
+        pending:    hsla(232, 201, 122), // #E8C97A yellow
+        running:    hsla( 86, 206, 234), // #56CEEA cyan
+        stopped:    hsla(160, 165, 175), // #A0A5AF gray
+        skipped:    hsla(199, 146, 234), // #C792EA purple
+
+        // Network
+        network_up:   hsla(126, 198, 153), // #7EC699 green
+        network_down: hsla(224,  96,  96), // #E06060 red
+        timeout:      hsla(213, 126, 234), // #D57EEA magenta
+        refused:      hsla(245, 160,  80), // #F5A050 orange
+
+        // Security
+        security:   hsla( 86, 206, 234), // #56CEEA cyan
+        auth:       hsla(126, 198, 153), // #7EC699 green
+        danger:     hsla(180,  50,  50), // #B43232 dark red
+
+        // Operations
+        started:    hsla(126, 198, 153), // #7EC699 green
+        stopped_op: hsla(224,  96,  96), // #E06060 red
+        restart:    hsla(232, 201, 122), // #E8C97A yellow
+        deploy:     hsla(100, 210, 140), // #64D28C bright green
+        crashed:    hsla(255,  50,  50), // #FF3232 bright red
+
+        // Resources
+        memory:     hsla(199, 146, 234), // #C792EA purple
+        cpu:        hsla( 86, 206, 234), // #56CEEA cyan
+        disk:       hsla(108, 180, 238), // #6CB4EE blue
+
+        // HTTP codes
+        http_2xx:   hsla(126, 198, 153), // #7EC699 green
+        http_3xx:   hsla( 86, 206, 234), // #56CEEA cyan
+        http_4xx:   hsla(232, 201, 122), // #E8C97A yellow
+        http_5xx:   hsla(224,  96,  96), // #E06060 red
+
+        // Dev
+        exception:  hsla(224,  96,  96), // #E06060 red
+        deprecated: hsla(245, 160,  80), // #F5A050 orange
+
+        // Existing
+        network:    hsla(199, 146, 234), // #C792EA purple
+        url:        hsla( 86, 212, 199), // #56D4C7 teal
+        port:       hsla(130, 170, 200), // #82AAC8 muted teal
     }
 }
 
-fn is_boundary(c: char) -> bool {
-    !c.is_ascii_alphanumeric() && c != '_'
+/// Highlight all occurrences of keyword list in `text`, writing to `map`.
+/// Case-insensitive, matches inside larger words (e.g. "my_ERROR" highlights "ERROR").
+/// Each keyword only matches once per position (no overlapping highlights).
+fn highlight_keywords(
+    map: &mut HashMap<(i32, i32), Hsla>,
+    text: &str,
+    byte_to_col: &[i32],
+    row_i32: i32,
+    keywords: &[&str],
+    color: Hsla,
+) {
+    for &kw in keywords {
+        let kw_lower: Vec<u8> = kw.bytes().map(|b| b.to_ascii_lowercase()).collect();
+        let text_bytes = text.as_bytes();
+        let text_lower: Vec<u8> = text_bytes.iter().map(|b| b.to_ascii_lowercase()).collect();
+        let mut start = 0;
+        while start + kw_lower.len() <= text_lower.len() {
+            if text_lower[start..].starts_with(&kw_lower) {
+                let abs = start;
+                let start_col = byte_to_col[abs];
+                let end_col = byte_to_col[(abs + kw.len() - 1).min(byte_to_col.len() - 1)];
+                for c in start_col..=end_col {
+                    map.entry((row_i32, c)).or_insert(color);
+                }
+                start = abs + kw.len();
+            } else {
+                start += 1;
+            }
+        }
+    }
+}
+
+/// Highlight HTTP status codes (200, 301, 404, 500, etc.)
+/// Only matches specific common HTTP codes, not all 3-digit numbers.
+fn highlight_http_codes(
+    map: &mut HashMap<(i32, i32), Hsla>,
+    text: &str,
+    byte_to_col: &[i32],
+    row_i32: i32,
+    colors: &HighlightColors,
+) {
+    let bytes = text.as_bytes();
+    let len = bytes.len();
+
+    // Specific HTTP codes to highlight
+    const HTTP_CODES: &[(u16, bool)] = &[
+        // 2xx
+        (200, true), (201, true), (202, true), (204, true), (206, true),
+        // 3xx
+        (301, true), (302, true), (304, true), (307, true), (308, true),
+        // 4xx
+        (400, true), (401, true), (403, true), (404, true), (405, true),
+        (408, true), (409, true), (410, true), (422, true), (429, true),
+        // 5xx
+        (500, true), (502, true), (503, true), (504, true),
+    ];
+
+    for i in 0..len.saturating_sub(2) {
+        if !bytes[i].is_ascii_digit() || !bytes[i + 1].is_ascii_digit() || !bytes[i + 2].is_ascii_digit() {
+            continue;
+        }
+
+        let code: u16 = ((bytes[i] - b'0') as u16) * 100
+            + ((bytes[i + 1] - b'0') as u16) * 10
+            + ((bytes[i + 2] - b'0') as u16);
+
+        // Only match specific codes
+        if !HTTP_CODES.iter().any(|&(c, _)| c == code) {
+            continue;
+        }
+
+        // Must be at a boundary (not part of a longer number)
+        let before_ok = i == 0 || !bytes[i - 1].is_ascii_digit();
+        let after_ok = i + 3 >= len || !bytes[i + 3].is_ascii_digit();
+        if !before_ok || !after_ok {
+            continue;
+        }
+
+        let color = match code {
+            200..=299 => colors.http_2xx,
+            300..=399 => colors.http_3xx,
+            400..=499 => colors.http_4xx,
+            500..=599 => colors.http_5xx,
+            _ => continue,
+        };
+
+        let start_col = byte_to_col[i];
+        let end_col = byte_to_col[(i + 2).min(byte_to_col.len() - 1)];
+        for c in start_col..=end_col {
+            map.entry((row_i32, c)).or_insert(color);
+        }
+    }
 }
 
 pub fn highlight_cells(
@@ -77,7 +255,6 @@ pub fn highlight_cells(
 ) -> HashMap<(i32, i32), Hsla> {
     let colors = highlight_colors();
 
-    // Pre-allocate the outer vector to the size of rows.
     let mut row_chars: Vec<Vec<(i32, char)>> = vec![Vec::with_capacity(128); rows];
     for rc in cells {
         if rc.row < 0 || (rc.row as usize) >= rows {
@@ -91,7 +268,6 @@ pub fn highlight_cells(
 
     let mut map = HashMap::new();
 
-    // Reusable buffers to avoid allocation inside the loop
     let mut chars_buf = String::with_capacity(128);
     let mut byte_to_col: Vec<i32> = Vec::with_capacity(128);
 
@@ -112,96 +288,210 @@ pub fn highlight_cells(
         }
         let text = chars_buf.as_str();
 
-        // ── 1. Error keywords ──────────────────────────
-        for kw in &["EMERGENCY", "CRITICAL", "FATAL", "PANIC", "ERROR", "ERR"] {
-            for m in find_keyword(text, kw) {
-                let start_col = byte_to_col[m];
-                let end_col = byte_to_col[(m + kw.len()).min(byte_to_col.len() - 1)];
-                for c in start_col..=end_col {
-                    map.entry((row_i32, c)).or_insert(colors.error);
-                }
-            }
-        }
+        // ── 1. Critical errors (highest priority) ──────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["PANIC", "EMERGENCY", "FATAL", "SEGFAULT", "CRITICAL",
+              "OOM", "OUT OF MEMORY", "KERNEL PANIC", "CORE DUMPED", "BUS ERROR"],
+            colors.critical,
+        );
 
-        // ── 2. Success keywords ───────────────────────────
-        for kw in &["SUCCESS", "SUCCEEDED", "PASSED", "PASS", "OK"] {
-            for m in find_keyword(text, kw) {
-                let start_col = byte_to_col[m];
-                let end_col = byte_to_col[(m + kw.len()).min(byte_to_col.len() - 1)];
-                for c in start_col..=end_col {
-                    map.entry((row_i32, c)).or_insert(colors.success);
-                }
-            }
-        }
+        // ── 2. Error keywords ──────────────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["ERROR", "ERR"], colors.error);
 
-        // ── 3. Failure keywords ───────────────────────────
-        for kw in &["FAILED", "FAILURE", "DENIED", "REJECTED", "TIMEOUT", "FAIL"] {
-            for m in find_keyword(text, kw) {
-                let start_col = byte_to_col[m];
-                let end_col = byte_to_col[(m + kw.len()).min(byte_to_col.len() - 1)];
-                for c in start_col..=end_col {
-                    map.entry((row_i32, c)).or_insert(colors.failure);
-                }
-            }
-        }
+        // ── 3. Alert ───────────────────────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["ALERT"], colors.alert);
 
-        // ── 4. Warning keywords ───────────────────────────
-        for kw in &["WARNING", "WARN"] {
-            for m in find_keyword(text, kw) {
-                let start_col = byte_to_col[m];
-                let end_col = byte_to_col[(m + kw.len()).min(byte_to_col.len() - 1)];
-                for c in start_col..=end_col {
-                    map.entry((row_i32, c)).or_insert(colors.warning);
-                }
-            }
-        }
+        // ── 4. Warning keywords ────────────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["WARNING", "WARN"], colors.warning);
 
-        // ── 5. Info keywords ──────────────────────────────
-        for kw in &["NOTICE", "INFO"] {
-            for m in find_keyword(text, kw) {
-                let start_col = byte_to_col[m];
-                let end_col = byte_to_col[(m + kw.len()).min(byte_to_col.len() - 1)];
-                for c in start_col..=end_col {
-                    map.entry((row_i32, c)).or_insert(colors.info);
-                }
-            }
-        }
+        // ── 5. Info keywords ───────────────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["INFO", "INFORMATION", "NOTICE"], colors.info);
 
-        // ── 6. Debug keywords ─────────────────────────────
-        for kw in &["DEBUG", "DBG", "TRACE"] {
-            for m in find_keyword(text, kw) {
-                let start_col = byte_to_col[m];
-                let end_col = byte_to_col[(m + kw.len()).min(byte_to_col.len() - 1)];
-                for c in start_col..=end_col {
-                    map.entry((row_i32, c)).or_insert(colors.debug);
-                }
-            }
-        }
+        // ── 6. Debug keywords ──────────────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["DEBUG", "DBG", "TRACE"], colors.debug);
 
-        // ── 7. IP addresses ───────────────────────────────
+        // ── 7. Success status ──────────────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["SUCCESS", "SUCCEEDED", "SUCCESSFUL", "PASSED", "PASS",
+              "OK", "DONE", "COMPLETED", "FINISHED", "COMPLETE"],
+            colors.success,
+        );
+
+        // ── 8. Failure status ──────────────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["FAILED", "FAILURE", "FAIL", "NOT OK"],
+            colors.failure,
+        );
+
+        // ── 9. Pending / Waiting ───────────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["PENDING", "WAITING", "PROCESSING", "IN PROGRESS", "QUEUED"],
+            colors.pending,
+        );
+
+        // ── 10. Running / Active ───────────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["RUNNING", "ACTIVE", "EXECUTING", "IN_PROGRESS", "LIVE"],
+            colors.running,
+        );
+
+        // ── 11. Stopped / Inactive ─────────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["STOPPED", "INACTIVE", "HALTED", "IDLE", "PAUSED"],
+            colors.stopped,
+        );
+
+        // ── 12. Skipped ────────────────────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["SKIPPED", "SKIP", "SKIPPING"], colors.skipped);
+
+        // ── 13. Network UP ─────────────────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["UP", "ONLINE", "CONNECTED", "REACHABLE", "LISTENING",
+              "ESTABLISHED", "LINK UP"],
+            colors.network_up,
+        );
+
+        // ── 14. Network DOWN ───────────────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["DOWN", "OFFLINE", "UNREACHABLE", "DISCONNECTED",
+              "NOT LISTENING", "LINK DOWN", "NO CARRIER"],
+            colors.network_down,
+        );
+
+        // ── 15. Timeout ────────────────────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["TIMEOUT", "TIMED OUT", "TIMEOUTS", "ETIMEDOUT", "SLOW", "LATENCY"],
+            colors.timeout,
+        );
+
+        // ── 16. Refused / Denied ───────────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["REFUSED", "REJECTED", "DENIED", "PERMISSION DENIED",
+              "ACCESS DENIED", "FORBIDDEN", "BLOCKED", "DROP"],
+            colors.refused,
+        );
+
+        // ── 17. Security / Protocol ────────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["SSH", "SSHD", "SSL", "TLS", "HTTPS", "CERTIFICATE", "CERT",
+              "FIREWALL", "IPTABLES", "ACL", "WAF"],
+            colors.security,
+        );
+
+        // ── 18. Authentication ─────────────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["AUTHENTICATED", "ACCEPTED", "AUTHORIZED", "LOGIN", "LOGOUT",
+              "LOGGED IN", "LOGGED OUT", "SESSION"],
+            colors.auth,
+        );
+
+        // ── 19. Danger (root/sudo/secrets) ─────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["ROOT", "SUDO", "UID=0", "PASSWORD", "SECRET", "TOKEN",
+              "API_KEY", "APIKEY", "PRIVATE KEY", "CREDENTIALS"],
+            colors.danger,
+        );
+
+        // ── 20. Operations: Start ──────────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["STARTED", "START", "STARTING", "BOOT", "BOOTING", "LAUNCHED", "LAUNCH"],
+            colors.started,
+        );
+
+        // ── 21. Operations: Stop ───────────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["STOPPED", "STOP", "STOPPING", "SHUTDOWN", "SHUTTING DOWN", "TERMINATED"],
+            colors.stopped_op,
+        );
+
+        // ── 22. Operations: Restart ────────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["RESTARTED", "RESTART", "RESTARTING", "RELOAD", "RELOADED", "RELOADING"],
+            colors.restart,
+        );
+
+        // ── 23. Operations: Deploy ─────────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["DEPLOYED", "DEPLOYMENT", "DEPLOYING", "DEPLOY",
+              "ROLLBACK", "ROLLED BACK", "ROLLING BACK", "UPGRADE", "UPGRADED"],
+            colors.deploy,
+        );
+
+        // ── 24. Operations: Crash ──────────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["CRASH", "CRASHED", "CRASHING", "SIGSEGV", "SIGABRT", "SIGKILL",
+              "DIED", "EXITED", "EXIT CODE", "CORE DUMP"],
+            colors.crashed,
+        );
+
+        // ── 25. Resources: Memory ──────────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["MEMORY", "RAM", "HEAP", "STACK", "SWAP", "MEM"],
+            colors.memory,
+        );
+
+        // ── 26. Resources: CPU ─────────────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["CPU", "PROCESSOR", "CORE", "CORES", "THREAD", "THREADS", "LOAD"],
+            colors.cpu,
+        );
+
+        // ── 27. Resources: Disk ────────────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["DISK", "STORAGE", "PARTITION", "MOUNT", "FILESYSTEM",
+              "INODE", "IOPS", "READ", "WRITE"],
+            colors.disk,
+        );
+
+        // ── 28. Dev: Exceptions ────────────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["EXCEPTION", "TRACEBACK", "THROW", "THROWN", "STACKTRACE",
+              "TYPEERROR", "VALUEERROR", "KEYERROR", "ATTRIBUTEERROR",
+              "INDEXERROR", "RUNTIMEERROR", "IOERROR", "OSERROR",
+              "NULLPOINTER", "NPE", "SEGFAULT"],
+            colors.exception,
+        );
+
+        // ── 29. Dev: Deprecated / TODO ─────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["DEPRECATED", "TODO", "FIXME", "HACK", "XXX", "WORKAROUND", "TEMPORARY"],
+            colors.deprecated,
+        );
+
+        // ── 30. HTTP status codes ──────────────────────────────
+        highlight_http_codes(&mut map, text, &byte_to_col, row_i32, &colors);
+
+        // ── 31. IP addresses ───────────────────────────────────
         for m in find_ip_addresses(text) {
+            let ip_len = find_ip_len(&text[m..]);
             let start_col = byte_to_col[m];
-            let end_col = byte_to_col[(m + find_ip_len(&text[m..])).min(byte_to_col.len() - 1)];
+            let end_col = byte_to_col[(m + ip_len - 1).min(byte_to_col.len() - 1)];
             for c in start_col..=end_col {
                 map.entry((row_i32, c)).or_insert(colors.network);
             }
         }
 
-        // ── 8. URLs ───────────────────────────────────────
+        // ── 32. URLs ───────────────────────────────────────────
         for m in find_urls(text) {
             let url_len = find_url_len(&text[m..]);
             let start_col = byte_to_col[m];
-            let end_col = byte_to_col[(m + url_len).min(byte_to_col.len() - 1)];
+            let end_col = byte_to_col[(m + url_len - 1).min(byte_to_col.len() - 1)];
             for c in start_col..=end_col {
                 map.entry((row_i32, c)).or_insert(colors.url);
             }
         }
 
-        // ── 9. Port numbers ─────────────────────────────────────
+        // ── 33. Port numbers ───────────────────────────────────
         for m in find_ports(text) {
             let port_len = find_port_len(&text[m..]);
             let start_col = byte_to_col[m];
-            let end_col = byte_to_col[(m + port_len).min(byte_to_col.len() - 1)];
+            let end_col = byte_to_col[(m + port_len - 1).min(byte_to_col.len() - 1)];
             for c in start_col..=end_col {
                 map.entry((row_i32, c)).or_insert(colors.port);
             }
@@ -211,26 +501,6 @@ pub fn highlight_cells(
     map
 }
 
-fn find_keyword(text: &str, keyword: &str) -> Vec<usize> {
-    let mut positions = Vec::new();
-    let mut start = 0;
-    while let Some(pos) = text[start..].find(keyword) {
-        let abs = start + pos;
-        let before_ok = abs == 0
-            || text.as_bytes()[abs - 1] == b' '
-            || is_boundary(text.as_bytes()[abs - 1] as char);
-        let after_pos = abs + keyword.len();
-        let after_ok = after_pos >= text.len()
-            || text.as_bytes()[after_pos] == b' '
-            || is_boundary(text.as_bytes()[after_pos] as char);
-        if before_ok && after_ok {
-            positions.push(abs);
-        }
-        start = abs + keyword.len();
-    }
-    positions
-}
-
 fn find_ip_len(text: &str) -> usize {
     let bytes = text.as_bytes();
     let mut dots = 0u8;
@@ -255,7 +525,7 @@ fn find_ip_len(text: &str) -> usize {
                 }
                 digits = 0;
             }
-            _ => break,
+            _ => break, // Stop at first non-digit/non-dot (including '/')
         }
         len += 1;
     }
@@ -292,6 +562,10 @@ fn find_ip_addresses(text: &str) -> Vec<usize> {
     positions
 }
 
+fn is_boundary(c: char) -> bool {
+    !c.is_ascii_alphanumeric() && c != '_'
+}
+
 fn find_urls(text: &str) -> Vec<usize> {
     let mut positions = Vec::new();
     let mut start = 0;

src/terminal/input.rs

@@ -112,6 +112,29 @@ impl Ashell {
             }
         }
 
+        // If the active tab is disconnected and user presses Enter, reconnect
+        if event.keystroke.key == "enter"
+            && !event.keystroke.modifiers.shift
+            && !event.keystroke.modifiers.control
+            && !event.keystroke.modifiers.alt
+            && !event.keystroke.modifiers.platform
+        {
+            let active_id = self.active_tab.clone();
+            if let Some(active_id) = active_id {
+                let is_disconnected = self
+                    .tabs
+                    .iter()
+                    .find(|t| t.id == active_id)
+                    .is_some_and(|tab| tab.disconnected_reason.is_some());
+                if is_disconnected {
+                    self.retry_disconnected_tab(&active_id, cx);
+                    window.prevent_default();
+                    cx.stop_propagation();
+                    return;
+                }
+            }
+        }
+
         if event.prefer_character_input {
             if let Some(text) = event.keystroke.key_char.as_deref() {
                 if !text.is_empty()
@@ -138,7 +161,7 @@ impl Ashell {
         tab.clear_selection();
 
         if let Some(bytes) = encode_key(&event.keystroke, tab.app_cursor_mode(), false) {
-            tab.backend.send(BackendCommand::Input(bytes));
+            tab.send_backend(BackendCommand::Input(bytes));
             window.prevent_default();
             cx.stop_propagation();
             cx.notify();
@@ -176,13 +199,13 @@ impl Ashell {
         }
 
         tab.clear_selection();
-        tab.backend.send(BackendCommand::Input(bytes));
+        tab.send_backend(BackendCommand::Input(bytes));
         window.prevent_default();
         cx.stop_propagation();
         cx.notify();
     }
 
-    fn active_terminal_selection_text(&self) -> Option<String> {
+    pub(crate) fn active_terminal_selection_text(&self) -> Option<String> {
         let active_id = self.active_tab.as_ref()?;
         self.tabs
             .iter()
@@ -190,7 +213,7 @@ impl Ashell {
             .and_then(|tab| tab.selection_text())
     }
 
-    fn paste_into_terminal(&mut self, text: &str, window: &mut Window, cx: &mut Context<Self>) {
+    pub(crate) 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;
         };
@@ -258,8 +281,7 @@ impl Ashell {
         }
         tab.clear_selection();
         self.terminal_marked_text = None;
-        tab.backend
-            .send(BackendCommand::Input(text.as_bytes().to_vec()));
+        tab.send_backend(BackendCommand::Input(text.as_bytes().to_vec()));
         window.invalidate_character_coordinates();
         cx.notify();
     }
@@ -517,8 +539,7 @@ impl Ashell {
                         }
                     }
                     if !bytes.is_empty() {
-                        tab.backend
-                            .send(crate::terminal::BackendCommand::Input(bytes));
+                        tab.send_backend(crate::terminal::BackendCommand::Input(bytes));
                     }
                 }
                 window.prevent_default();
@@ -532,8 +553,7 @@ impl Ashell {
                     bytes.extend_from_slice(&[b'\x1b', b'O', code]);
                 }
                 if !bytes.is_empty() {
-                    tab.backend
-                        .send(crate::terminal::BackendCommand::Input(bytes));
+                    tab.send_backend(crate::terminal::BackendCommand::Input(bytes));
                 }
                 window.prevent_default();
                 cx.stop_propagation();

src/terminal/mod.rs

@@ -138,12 +138,20 @@ pub struct TerminalTab {
     pub kind: TabKind,
     pub status: String,
     pub connected: bool,
+    pub disconnected_reason: Option<String>,
+    /// Incremented each time the tab is reconnected. Used to ignore stale
+    /// `BackendEvent::Closed` from the previous backend after a retry.
+    pub backend_generation: u32,
+    /// Set to `true` when the current backend sends its first `Output` or
+    /// `Connected` event. Used to skip stale `Closed` events that arrive
+    /// before the new backend has started producing output.
+    pub backend_initialized: bool,
     pub session: Option<Session>,
     processor: Processor,
     term: Term<TerminalListener>,
-    cols: u16,
-    rows: u16,
-    pub backend: BackendTx,
+    pub cols: u16,
+    pub rows: u16,
+    pub backend: std::sync::Arc<std::sync::Mutex<BackendTx>>,
     pub scroll_pixel_y: f32,
     pub(crate) highlight_cache: std::cell::RefCell<Option<(Vec<RenderCell>, std::collections::HashMap<(i32, i32), gpui::Hsla>)>>,
 }
@@ -241,18 +249,22 @@ impl TerminalTab {
         backend: BackendTx,
         events: std::sync::mpsc::Sender<BackendEvent>,
     ) -> Self {
+        let shared_backend = std::sync::Arc::new(std::sync::Mutex::new(backend));
         Self {
             id: id.clone(),
             title,
             kind,
             status,
             connected: matches!(kind, TabKind::Local),
+            disconnected_reason: None,
+            backend_generation: 0,
+            backend_initialized: true,
             session: None,
             processor: Processor::new(),
-            term: new_term(100, 30, backend.clone(), id, events),
+            term: new_term(100, 30, shared_backend.clone(), id, events),
             cols: 100,
             rows: 30,
-            backend,
+            backend: shared_backend,
             scroll_pixel_y: 0.0,
             highlight_cache: std::cell::RefCell::new(None),
         }
@@ -262,6 +274,22 @@ impl TerminalTab {
         self.processor.advance(&mut self.term, bytes);
     }
 
+    /// Send a command to the backend. Thread-safe via the shared Arc<Mutex>.
+    pub fn send_backend(&self, command: BackendCommand) {
+        if let Ok(backend) = self.backend.lock() {
+            backend.send(command);
+        }
+    }
+
+    /// Replace the backend with a new one. The `Term`'s internal listener
+    /// shares the same `Arc`, so user input is automatically routed to the
+    /// new backend. The old backend must be closed by the caller.
+    pub fn set_backend(&self, new_backend: BackendTx) {
+        if let Ok(mut backend) = self.backend.lock() {
+            *backend = new_backend;
+        }
+    }
+
     pub fn resize(&mut self, cols: u16, rows: u16) {
         let new_cols = cols.max(1);
         let new_rows = rows.max(1);
@@ -274,7 +302,7 @@ impl TerminalTab {
                 self.rows
             );
             self.term.resize(TerminalSize::new(self.cols, self.rows));
-            self.backend.send(BackendCommand::Resize { cols, rows });
+            self.send_backend(BackendCommand::Resize { cols, rows });
         }
     }
 
@@ -339,7 +367,7 @@ impl TerminalTab {
 
         let highlights = if is_enabled {
             let mut cache = self.highlight_cache.borrow_mut();
-            let cache_valid = cache.as_ref().map_or(false, |(cached_cells, _)| {
+            let cache_valid = cache.as_ref().is_some_and(|(cached_cells, _)| {
                 cached_cells == &cells
             });
             if cache_valid {
@@ -467,8 +495,7 @@ impl TerminalTab {
             .replace("\r\n", "\r")
             .replace('\n', "\r");
 
-        self.backend
-            .send(BackendCommand::Input(paste_text.into_bytes()));
+        self.send_backend(BackendCommand::Input(paste_text.into_bytes()));
     }
 }
 
@@ -518,16 +545,18 @@ fn viewport_selection_from_range(
 #[derive(Clone)]
 struct TerminalListener {
     tab_id: String,
-    backend: BackendTx,
+    backend: std::sync::Arc<std::sync::Mutex<BackendTx>>,
     events: std::sync::mpsc::Sender<BackendEvent>,
 }
 
 impl EventListener for TerminalListener {
     fn send_event(&self, event: Event) {
         match event {
-            Event::PtyWrite(output) => self
-                .backend
-                .send(BackendCommand::Input(output.into_bytes())),
+            Event::PtyWrite(output) => {
+                if let Ok(backend) = self.backend.lock() {
+                    backend.send(BackendCommand::Input(output.into_bytes()));
+                }
+            }
             Event::TextAreaSizeRequest(format) => {
                 let size = alacritty_terminal::event::WindowSize {
                     num_lines: 30,
@@ -535,8 +564,9 @@ impl EventListener for TerminalListener {
                     cell_width: 8,
                     cell_height: 16,
                 };
-                self.backend
-                    .send(BackendCommand::Input(format(size).into_bytes()));
+                if let Ok(backend) = self.backend.lock() {
+                    backend.send(BackendCommand::Input(format(size).into_bytes()));
+                }
             }
             Event::Title(title) => {
                 let _ = self.events.send(BackendEvent::TerminalTitleChanged {
@@ -552,7 +582,7 @@ impl EventListener for TerminalListener {
 fn new_term(
     cols: u16,
     rows: u16,
-    backend: BackendTx,
+    backend: std::sync::Arc<std::sync::Mutex<BackendTx>>,
     tab_id: String,
     events: std::sync::mpsc::Sender<BackendEvent>,
 ) -> Term<TerminalListener> {