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"] }

assets/themes/phygerr.json

@@ -0,0 +1,308 @@
+{
+  "$schema": "https://github.com/longbridge/gpui-component/raw/refs/heads/main/.theme-schema.json",
+  "name": "Phyger",
+  "author": "phygerr",
+  "url": "https://github.com/phygerr",
+  "themes": [
+    {
+      "name": "Phyger Light",
+      "mode": "light",
+      "colors": {
+        "accent.background": "#D6E4F0",
+        "accent.foreground": "#1B3A5C",
+        "background": "#F8F9FC",
+        "border": "#D0D5DD",
+        "danger.background": "#D94848",
+        "danger.active.background": "#B53535",
+        "danger.foreground": "#FFFFFF",
+        "foreground": "#2B2D30",
+        "input.border": "#C0C7D0",
+        "link.active.foreground": "#2563EB",
+        "link.foreground": "#2563EB",
+        "link.hover.foreground": "#1D4ED8",
+        "list.active.background": "#2563EB18",
+        "list.hover.background": "#E8EDF4",
+        "list.active.border": "#2563EB",
+        "list.even.background": "#F0F2F7",
+        "muted.background": "#E2E6EE88",
+        "muted.foreground": "#7A7F88",
+        "panel.background": "#ECEEF3",
+        "popover.background": "#F8F9FC",
+        "popover.foreground": "#2B2D30",
+        "primary.active.background": "#1D4ED8",
+        "primary.background": "#2563EB",
+        "primary.foreground": "#FFFFFF",
+        "primary.hover.background": "#3B72F0",
+        "ring": "#2563EB",
+        "scrollbar.background": "#F8F9FC00",
+        "scrollbar.thumb.background": "#C0C7D0",
+        "secondary.background": "#E8EDF4",
+        "secondary.active.background": "#D0D5DD",
+        "secondary.foreground": "#2B2D30",
+        "secondary.hover.background": "#DCE2EB",
+        "tab.active.background": "#F8F9FC",
+        "tab.active.foreground": "#2B2D30",
+        "tab.background": "#ECEEF300",
+        "tab.foreground": "#7A7F88",
+        "tab_bar.background": "#ECEEF3",
+        "title_bar.background": "#ECEEF3",
+        "title_bar.border": "#D0D5DD",
+        "base.magenta.light": "#C2185B44",
+        "base.red": "#D32F2F",
+        "base.green": "#2E7D32",
+        "base.yellow": "#BF8C00",
+        "base.blue": "#1565C0",
+        "base.magenta": "#8E24AA",
+        "base.cyan": "#00838F"
+      },
+      "highlight": {
+        "editor.foreground": "#2B2D30",
+        "editor.background": "#F8F9FC",
+        "editor.active_line.background": "#E8EDF4",
+        "editor.line_number": "#A0A5AE",
+        "editor.active_line_number": "#2B2D30",
+        "editor.invisible": "#A0A5AE55",
+        "conflict": "#D32F2F",
+        "created": "#2E7D32",
+        "deleted": "#C62828",
+        "error": "#D32F2F",
+        "hidden": "#A0A5AE",
+        "hint": "#1565C0",
+        "ignored": "#A0A5AE",
+        "info": "#00838F",
+        "modified": "#BF8C00",
+        "predictive": "#A0A5AE",
+        "renamed": "#BF8C00",
+        "success": "#2E7D32",
+        "unreachable": "#A0A5AE",
+        "warning": "#E65100",
+        "syntax": {
+          "attribute": {
+            "color": "#7B1FA2"
+          },
+          "boolean": {
+            "color": "#00838F"
+          },
+          "comment": {
+            "color": "#6A737D",
+            "font_style": "italic"
+          },
+          "comment.doc": {
+            "color": "#6A737D",
+            "font_style": "italic"
+          },
+          "constant": {
+            "color": "#00838F"
+          },
+          "constructor": {
+            "color": "#1565C0"
+          },
+          "embedded": {
+            "color": "#2B2D30"
+          },
+          "function": {
+            "color": "#6A1B9A"
+          },
+          "keyword": {
+            "color": "#1565C0"
+          },
+          "link_text": {
+            "color": "#1565C0",
+            "font_style": "normal"
+          },
+          "link_uri": {
+            "color": "#00838F",
+            "font_style": "italic"
+          },
+          "number": {
+            "color": "#1B5E20"
+          },
+          "string": {
+            "color": "#BF360C"
+          },
+          "string.escape": {
+            "color": "#BF360C"
+          },
+          "string.regex": {
+            "color": "#BF360C"
+          },
+          "string.special": {
+            "color": "#00838F"
+          },
+          "string.special.symbol": {
+            "color": "#00838F"
+          },
+          "tag": {
+            "color": "#1565C0"
+          },
+          "text.literal": {
+            "color": "#00838F"
+          },
+          "title": {
+            "color": "#6A1B9A",
+            "font_weight": 600
+          },
+          "type": {
+            "color": "#2E7D32"
+          },
+          "property": {
+            "color": "#2B2D30"
+          },
+          "variable.special": {
+            "color": "#D32F2F"
+          }
+        }
+      }
+    },
+    {
+      "name": "Phyger Dark",
+      "mode": "dark",
+      "colors": {
+        "accent.background": "#2A3040",
+        "accent.foreground": "#C8D3E0",
+        "background": "#1A1D23",
+        "border": "#2E3340",
+        "danger.background": "#E05555",
+        "danger.active.background": "#CC3D3D",
+        "danger.foreground": "#FFFFFF",
+        "foreground": "#C8CED8",
+        "input.border": "#3A4050",
+        "link.active.foreground": "#6CB4EE",
+        "link.foreground": "#6CB4EE",
+        "link.hover.foreground": "#8FC8F6",
+        "list.active.background": "#6CB4EE15",
+        "list.hover.background": "#252A34",
+        "list.active.border": "#6CB4EE",
+        "list.even.background": "#1E2229",
+        "muted.background": "#252A3466",
+        "muted.foreground": "#6B7280",
+        "panel.background": "#1E2229",
+        "popover.background": "#1A1D23",
+        "popover.foreground": "#C8CED8",
+        "primary.active.background": "#4A90D9",
+        "primary.background": "#5BA0E0",
+        "primary.foreground": "#1A1D23",
+        "primary.hover.background": "#6CB4EE",
+        "ring": "#5BA0E0",
+        "scrollbar.background": "#1A1D2300",
+        "scrollbar.thumb.background": "#3A4050",
+        "secondary.active.background": "#333A48",
+        "secondary.background": "#252A34",
+        "secondary.foreground": "#C8CED8",
+        "secondary.hover.background": "#2E3542",
+        "tab.active.background": "#1A1D23",
+        "tab.active.foreground": "#C8CED8",
+        "tab.background": "#252A3400",
+        "tab.foreground": "#6B7280",
+        "tab_bar.background": "#1E2229DD",
+        "title_bar.background": "#1E2229",
+        "title_bar.border": "#2E3340",
+        "base.magenta.light": "#C792EA44",
+        "base.red": "#E06060",
+        "base.green": "#7EC699",
+        "base.yellow": "#E8C97A",
+        "base.blue": "#6CB4EE",
+        "base.magenta": "#C792EA",
+        "base.cyan": "#56D4C7"
+      },
+      "highlight": {
+        "editor.foreground": "#C8CED8",
+        "editor.background": "#1A1D23",
+        "editor.active_line.background": "#222730",
+        "editor.line_number": "#5A6170",
+        "editor.active_line_number": "#C8CED8",
+        "editor.invisible": "#5A617055",
+        "conflict": "#E06060",
+        "created": "#7EC699",
+        "deleted": "#CC4444",
+        "error": "#E06060",
+        "hidden": "#6B7280",
+        "hint": "#C792EA",
+        "ignored": "#5A6170",
+        "info": "#56D4C7",
+        "modified": "#E8C97A",
+        "predictive": "#4A5568",
+        "renamed": "#E8C97A",
+        "success": "#7EC699",
+        "unreachable": "#5A6170",
+        "warning": "#E8C97A",
+        "syntax": {
+          "attribute": {
+            "color": "#C792EA"
+          },
+          "boolean": {
+            "color": "#56D4C7"
+          },
+          "comment": {
+            "color": "#5A6A7A",
+            "font_style": "italic"
+          },
+          "comment.doc": {
+            "color": "#5A6A7A",
+            "font_style": "italic"
+          },
+          "constant": {
+            "color": "#56D4C7"
+          },
+          "constructor": {
+            "color": "#6CB4EE"
+          },
+          "embedded": {
+            "color": "#C8CED8"
+          },
+          "function": {
+            "color": "#E2C08D"
+          },
+          "keyword": {
+            "color": "#6CB4EE"
+          },
+          "link_text": {
+            "color": "#6CB4EE",
+            "font_style": "normal"
+          },
+          "link_uri": {
+            "color": "#56D4C7",
+            "font_style": "italic"
+          },
+          "number": {
+            "color": "#7EC699"
+          },
+          "string": {
+            "color": "#E8A87C"
+          },
+          "string.escape": {
+            "color": "#E8A87C"
+          },
+          "string.regex": {
+            "color": "#E8A87C"
+          },
+          "string.special": {
+            "color": "#56D4C7"
+          },
+          "string.special.symbol": {
+            "color": "#56D4C7"
+          },
+          "tag": {
+            "color": "#6CB4EE"
+          },
+          "text.literal": {
+            "color": "#56D4C7"
+          },
+          "title": {
+            "color": "#E2C08D",
+            "font_weight": 600
+          },
+          "type": {
+            "color": "#7EC699"
+          },
+          "property": {
+            "color": "#C8CED8"
+          },
+          "variable.special": {
+            "color": "#E06060"
+          }
+        }
+      }
+    }
+  ]
+}

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}..."
@@ -111,7 +124,10 @@ zombie_reason: "This transfer was interrupted because the application exited. Th
 software_builtin: "Built-in"
 retry: "Retry"
 right_click_copy_paste: "Right-click Copy/Paste"
-copy_paste_hint: "Regardless of this switch, you can always use %{key} + C/V to copy/paste."
+keyword_highlight: "Terminal Keyword Highlighting"
+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}"
@@ -142,6 +158,9 @@ files_uploading: "%{count} files uploading"
 panel_minimize: "Minimize Panel"
 panel_expand: "Expand Panel"
 settings_new_ssh: "New SSH"
+settings_open_search: "Search"
+search: "Search"
+no_results: "No results"
 settings_toggle_sidebar: "Toggle Sidebar"
 settings_toggle_sftp_zoom: "Toggle SFTP Zoom"
 settings_focus_pane_left: "Focus Pane Left"
@@ -180,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}..."
@@ -112,7 +125,10 @@ zombie_reason: "此传输任务因程序退出而中断，传输进程已不存
 software_builtin: "软件内置"
 retry: "重试"
 right_click_copy_paste: "右键复制/粘贴"
-copy_paste_hint: "不管是否开启此开关，都可以使用 %{key} + C/V 快捷键进行复制和粘贴。"
+keyword_highlight: "终端关键词高亮"
+copy_paste_hint: "选中后左键点击也可复制。"
+settings_copy: "复制选区"
+settings_paste: "粘贴剪贴板"
 edit_file: "编辑文件"
 edit_file_tooltip: "下载到临时目录，使用默认编辑器打开，并在保存后自动上传。"
 auto_saved_and_uploaded: "已自动保存并上传: %{base}"
@@ -144,6 +160,9 @@ files_uploading: "%{count} 个文件正在上传"
 panel_minimize: "折叠面板"
 panel_expand: "展开面板"
 settings_new_ssh: "新建 SSH"
+settings_open_search: "搜索"
+search: "搜索"
+no_results: "无结果"
 settings_toggle_sidebar: "缩放侧边栏"
 settings_toggle_sftp_zoom: "缩放 SFTP 面板"
 settings_focus_pane_left: "向左切换焦点"
@@ -182,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,26 @@ 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(
+                                                        t!("keyword_highlight").to_string(),
+                                                        SettingField::render({
+                                                            let view = view_clone_for_general.clone();
+                                                            move |_, window, cx| {
+                                                                Switch::new("keyword-highlight")
+                                                                    .small()
+                                                                    .checked(view.read(cx).config.keyword_highlight())
+                                                                    .on_click(window.listener_for(&view, |this, checked, _, cx| {
+                                                                        this.config.set_keyword_highlight(*checked);
+                                                                        let _ = this.config.save();
+                                                                        cx.notify();
+                                                                    }))
+                                                                    .into_any_element()
+                                                            }
+                                                        })
+                                                    )
                                                 )
                                                 .item(
                                                     SettingItem::new(
@@ -1746,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)
@@ -1857,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();
                     });
@@ -1870,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

@@ -18,6 +18,7 @@ gpui::actions!(
         OpenSession,
         OpenTransfers,
         NewSsh,
+        OpenSearch,
         ToggleSidebar,
         ToggleSftpZoom,
         FocusPaneLeft,
@@ -28,7 +29,9 @@ gpui::actions!(
         SplitPaneRight,
         SplitPaneUp,
         SplitPaneDown,
-        ClosePane
+        ClosePane,
+        Copy,
+        Paste
     ]
 );
 
@@ -62,6 +65,11 @@ pub(crate) const WORKSPACE_ACTIONS: &[WorkspaceAction] = &[
         label_key: "settings_new_ssh",
         default_suffix: "n",
     },
+    WorkspaceAction {
+        id: "OpenSearch",
+        label_key: "settings_open_search",
+        default_suffix: "f",
+    },
     WorkspaceAction {
         id: "ToggleSidebar",
         label_key: "settings_toggle_sidebar",
@@ -117,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 {
@@ -206,6 +224,7 @@ pub(crate) fn unbind_all_workspace_keys(cx: &mut App, config: &ConfigStore) {
     unbind_action!("OpenSession", crate::OpenSession);
     unbind_action!("OpenTransfers", crate::OpenTransfers);
     unbind_action!("NewSsh", crate::NewSsh);
+    unbind_action!("OpenSearch", crate::OpenSearch);
     unbind_action!("ToggleSidebar", crate::ToggleSidebar);
     unbind_action!("ToggleSftpZoom", crate::ToggleSftpZoom);
     unbind_action!("FocusPaneLeft", crate::FocusPaneLeft);
@@ -217,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);
 }
@@ -261,6 +282,7 @@ fn bind_workspace_actions(cx: &mut App, config: &ConfigStore) {
     bind_action!("OpenSession", crate::OpenSession);
     bind_action!("OpenTransfers", crate::OpenTransfers);
     bind_action!("NewSsh", crate::NewSsh);
+    bind_action!("OpenSearch", crate::OpenSearch);
     bind_action!("ToggleSidebar", crate::ToggleSidebar);
     bind_action!("ToggleSftpZoom", crate::ToggleSftpZoom);
     bind_action!("FocusPaneLeft", crate::FocusPaneLeft);
@@ -272,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);
 }
@@ -281,7 +305,7 @@ impl KeybindingsPage {
         let groups = [
             (
                 "settings_group_keybind_general",
-                vec!["OpenSettings", "OpenSession", "OpenTransfers", "NewSsh"],
+                vec!["OpenSettings", "OpenSession", "OpenTransfers", "NewSsh", "OpenSearch", "Copy", "Paste"],
             ),
             (
                 "settings_group_keybind_zoom",

src/app/mod.rs

@@ -2,6 +2,7 @@ pub mod config_sync;
 pub mod constants;
 pub mod dialogs;
 pub mod keybinding_recorder;
+pub mod search;
 pub mod startup;
 pub mod theme;
 pub mod ui;
@@ -210,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>,
@@ -248,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,
@@ -274,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>,
@@ -288,6 +298,14 @@ pub(crate) struct Ashell {
     pub(crate) last_system_sample: Instant,
     pub(crate) last_theme_sync: Instant,
 
+    pub(crate) search_input: Entity<InputState>,
+    pub(crate) search_active: bool,
+    pub(crate) search_query: String,
+    pub(crate) search_matches: Vec<(i32, i32)>,
+    pub(crate) search_current: usize,
+    pub(crate) search_target_tab: Option<String>,
+    pub(crate) search_bar_bounds: Option<Bounds<Pixels>>,
+
     pub(crate) system_tab_id: Option<String>,
     pub(crate) sftp_handles: std::collections::HashMap<String, crate::sftp::SftpHandle>,
 
@@ -295,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>,
 }
 
@@ -305,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,
@@ -365,13 +377,41 @@ 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()));
+        let search_input = cx.new(|cx| {
+            InputState::new(window, cx).placeholder(t!("search").to_string())
+        });
         let config = ConfigStore::load().unwrap_or_else(|err| {
             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/")
@@ -435,8 +475,13 @@ 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),
             cx.subscribe_in(&sync_endpoint_input, window, Self::on_input_event),
             cx.subscribe_in(&sync_username_input, window, Self::on_input_event),
             cx.subscribe_in(&sync_webdav_password_input, window, Self::on_input_event),
@@ -493,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(),
@@ -504,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,
@@ -526,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(),
@@ -545,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,
@@ -593,6 +651,14 @@ impl Ashell {
             last_system_sample: Instant::now(),
             last_theme_sync: Instant::now(),
 
+            search_input,
+            search_active: false,
+            search_query: String::new(),
+            search_matches: Vec::new(),
+            search_current: 0,
+            search_target_tab: None,
+            search_bar_bounds: None,
+
             system_tab_id: None,
             sftp_handles: std::collections::HashMap::new(),
 
@@ -600,6 +666,8 @@ impl Ashell {
             runtime: Runtime::new().expect("create tokio runtime"),
             events_rx,
             events_tx,
+            last_window_size: None,
+            last_sidebar_width,
             _subscriptions,
         };
 
@@ -651,6 +719,18 @@ impl Ashell {
                 }
                 _ => {}
             }
+        } else if input == &self.search_input {
+            if let InputEvent::PressEnter { .. } = event {
+                if self.search_query.is_empty()
+                    || self.search_input.read(cx).text().to_string() != self.search_query
+                {
+                    self.perform_search(window, cx);
+                } else {
+                    self.search_goto_next(cx);
+                }
+                window.prevent_default();
+                cx.stop_propagation();
+            }
         }
         cx.notify();
     }
@@ -658,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))
@@ -669,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 {
@@ -697,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,
@@ -802,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();
                 }
@@ -1006,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(
@@ -1033,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/search.rs

@@ -0,0 +1,486 @@
+use std::collections::HashMap;
+
+use gpui::{
+    Context, Focusable as _, Hsla, IntoElement, InteractiveElement as _, MouseButton,
+    ParentElement as _, Styled as _, Window, div, prelude::FluentBuilder as _, px, rems,
+};
+use gpui_component::{
+    ActiveTheme as _, Disableable as _, ElementExt as _, IconName, Sizable as _,
+    button::{Button, ButtonVariants as _},
+    h_flex, input::Input,
+};
+use rust_i18n::t;
+
+use crate::Ashell;
+
+impl Ashell {
+    pub(crate) fn toggle_search(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        if self.search_active {
+            self.close_search(window, cx);
+        } else {
+            self.open_search(window, cx);
+        }
+    }
+
+    pub(crate) fn open_search(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        self.search_active = true;
+        // Focus the search input on the next frame so it happens after the
+        // current render cycle completes, avoiding focus being stolen back
+        // by the terminal panel's track_focus.
+        let search_input = self.search_input.clone();
+        cx.on_next_frame(window, move |_this, window, cx| {
+            search_input.update(cx, |state, cx| {
+                state.focus_handle(cx).focus(window, cx);
+            });
+        });
+        cx.notify();
+    }
+
+    pub(crate) fn close_search(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        self.search_active = false;
+        self.search_query.clear();
+        self.search_matches.clear();
+        self.search_current = 0;
+        self.search_target_tab = None;
+        self.search_bar_bounds = None;
+        self.focus_handle.focus(window, cx);
+        cx.notify();
+    }
+
+    /// Move keyboard focus back to the search input so the user can keep typing.
+    /// Deferred to the next frame so it happens after the current render cycle,
+    /// preventing the terminal panel's track_focus from stealing focus back.
+    fn refocus_search_input(&self, window: &mut Window, cx: &mut Context<Self>) {
+        let search_input = self.search_input.clone();
+        cx.on_next_frame(window, move |_this, window, cx| {
+            search_input.update(cx, |state, cx| {
+                state.focus_handle(cx).focus(window, cx);
+            });
+        });
+    }
+
+    pub(crate) fn perform_search(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let query = self.search_input.read(cx).text().to_string();
+        if query.is_empty() {
+            self.search_query.clear();
+            self.search_matches.clear();
+            self.search_current = 0;
+            self.refocus_search_input(window, cx);
+            cx.notify();
+            return;
+        }
+
+        // Find the active tab — try active_tab first, then fall back to the
+        // first tab in the active group, then any tab.
+        let tab = self
+            .active_tab
+            .as_ref()
+            .and_then(|id| self.tabs.iter().find(|t| &t.id == id));
+
+        let tab = tab.or_else(|| {
+            let first_id = self
+                .active_group
+                .as_ref()
+                .and_then(|gid| self.tab_groups.iter().find(|g| &g.id == gid))
+                .and_then(|g| g.pane_root.tab_ids().into_iter().next())
+                .map(|s| s.to_string());
+            first_id
+                .as_deref()
+                .and_then(|id| self.tabs.iter().find(|t| t.id == id))
+        });
+
+        let tab = tab.or_else(|| self.tabs.first());
+
+        let Some(tab) = tab else {
+            self.status = t!("no_results").into();
+            self.refocus_search_input(window, cx);
+            cx.notify();
+            return;
+        };
+
+        // Remember which tab was searched so highlights only appear in that pane.
+        self.search_target_tab = Some(tab.id.clone());
+
+        let query_lower = query.to_lowercase();
+        let query_byte_len = query.len();
+
+        // Search the ENTIRE terminal buffer (scrollback + visible screen).
+        // full_grid_rows returns grid line indices; the first row is at
+        // `grid_start` (typically -history_size).
+        let (grid_start, all_rows) = tab.full_grid_rows();
+
+        let mut matches: Vec<(i32, i32)> = Vec::new();
+
+        for (row_idx, row) in all_rows.iter().enumerate() {
+            if row.is_empty() {
+                continue;
+            }
+
+            // Build text string and byte→column index mapping.
+            let mut text = String::with_capacity(row.len());
+            let mut byte_to_col: Vec<i32> = Vec::new();
+            for &(col, c) in row {
+                text.push(c);
+                while byte_to_col.len() < text.len() {
+                    byte_to_col.push(col);
+                }
+            }
+            let text_lower = text.to_lowercase();
+
+            // Grid line index for this row.
+            let abs_row = grid_start + row_idx as i32;
+
+            let mut search_start = 0;
+            while let Some(pos) = text_lower[search_start..].find(&query_lower) {
+                let abs = search_start + pos;
+                let start_col = byte_to_col[abs];
+                let end_byte = (abs + query_byte_len).min(byte_to_col.len());
+                let end_col = byte_to_col[end_byte - 1];
+                for c in start_col..=end_col {
+                    matches.push((abs_row, c));
+                }
+                search_start = abs + query_byte_len;
+            }
+        }
+
+        let match_count = count_match_groups(&matches);
+
+        self.search_query = query;
+        self.search_matches = matches;
+
+        if match_count > 0 {
+            self.search_current = 0;
+            self.jump_to_current_match(cx);
+        }
+
+        self.status = format!(
+            "{}: {} ({})",
+            t!("search"),
+            self.search_query,
+            if match_count == 0 {
+                t!("no_results").to_string()
+            } else {
+                format!("{}/{}", self.search_current + 1, match_count)
+            }
+        )
+        .into();
+
+        // Keep focus on the search input so the user can continue typing.
+        self.refocus_search_input(window, cx);
+        cx.notify();
+    }
+
+    pub(crate) fn search_goto_next(&mut self, cx: &mut Context<Self>) {
+        let match_count = count_match_groups(&self.search_matches);
+        if match_count == 0 {
+            return;
+        }
+        self.search_current = (self.search_current + 1) % match_count;
+        self.jump_to_current_match(cx);
+        cx.notify();
+    }
+
+    pub(crate) fn search_goto_prev(&mut self, cx: &mut Context<Self>) {
+        let match_count = count_match_groups(&self.search_matches);
+        if match_count == 0 {
+            return;
+        }
+        self.search_current = (self.search_current + match_count - 1) % match_count;
+        self.jump_to_current_match(cx);
+        cx.notify();
+    }
+
+    fn jump_to_current_match(&mut self, _cx: &mut Context<Self>) {
+        // target_grid_line is the grid line index (negative = history).
+        let Some((target_grid_line, _)) =
+            find_nth_match_start(&self.search_matches, self.search_current)
+        else {
+            return;
+        };
+
+        // Find the tab ID first (immutable borrow), then look up mutably.
+        let tab_id = self.active_tab.clone().or_else(|| {
+            self.active_group
+                .as_ref()
+                .and_then(|gid| self.tab_groups.iter().find(|g| &g.id == gid))
+                .and_then(|g| g.pane_root.tab_ids().into_iter().next())
+                .map(|s| s.to_string())
+        });
+
+        let tab = if let Some(id) = tab_id.as_deref() {
+            self.tabs.iter_mut().find(|t| t.id == id)
+        } else {
+            self.tabs.first_mut()
+        };
+
+        if let Some(tab) = tab {
+            let snapshot = tab.render_snapshot();
+            let display_offset = snapshot.display_offset as i32;
+            let rows = snapshot.rows as i32;
+
+            // viewport row = grid_line + display_offset
+            let vp_row = target_grid_line + display_offset;
+            let visible = vp_row >= 0 && vp_row < rows;
+
+            if !visible {
+                // Scroll so the target grid line appears near the top.
+                // display_offset = -grid_line puts it at viewport row 0.
+                let new_offset = (-target_grid_line).max(0) as usize;
+                if new_offset > snapshot.display_offset {
+                    tab.scroll_up_by(new_offset - snapshot.display_offset);
+                } else if new_offset < snapshot.display_offset {
+                    tab.scroll_down_by(snapshot.display_offset - new_offset);
+                }
+            }
+        }
+    }
+
+    /// Build a highlight map for search matches, converting grid line indices
+    /// to the current viewport coordinates. Only returns highlights for the
+    /// pane that was actually searched (`search_target_tab`).
+    pub(crate) fn search_highlight_map(
+        &self,
+        tab_id: &str,
+        match_color: Hsla,
+        current_color: Hsla,
+    ) -> Option<HashMap<(i32, i32), Hsla>> {
+        if self.search_matches.is_empty()
+            || self.search_query.is_empty()
+            || self.search_target_tab.as_deref() != Some(tab_id)
+        {
+            return None;
+        }
+
+        // Get current display_offset to convert grid line → viewport row.
+        let tab = self
+            .active_tab
+            .as_ref()
+            .and_then(|id| self.tabs.iter().find(|t| &t.id == id));
+
+        let tab = tab.or_else(|| {
+            let first_id = self
+                .active_group
+                .as_ref()
+                .and_then(|gid| self.tab_groups.iter().find(|g| &g.id == gid))
+                .and_then(|g| g.pane_root.tab_ids().into_iter().next())
+                .map(|s| s.to_string());
+            first_id
+                .as_deref()
+                .and_then(|id| self.tabs.iter().find(|t| t.id == id))
+        });
+
+        let tab = tab.or_else(|| self.tabs.first());
+
+        let Some(tab) = tab else {
+            return None;
+        };
+        let snapshot = tab.render_snapshot();
+        let display_offset = snapshot.display_offset as i32;
+        let rows = snapshot.rows as i32;
+
+        let mut map = HashMap::new();
+
+        let mut sorted: Vec<(i32, i32)> = self.search_matches.clone();
+        sorted.sort();
+
+        let mut group_idx = 0;
+        let mut i = 0;
+        while i < sorted.len() {
+            let is_current = group_idx == self.search_current;
+            let color = if is_current {
+                current_color
+            } else {
+                match_color
+            };
+
+            // grid_line → viewport row:  vp_row = grid_line + display_offset
+            let (grid_line, _) = sorted[i];
+            let vp_row = grid_line + display_offset;
+            let mut j = i;
+            if vp_row >= 0 && vp_row < rows {
+                while j < sorted.len() && sorted[j].0 == grid_line {
+                    if j > i && sorted[j].1 != sorted[j - 1].1 + 1 {
+                        break;
+                    }
+                    map.insert((vp_row, sorted[j].1), color);
+                    j += 1;
+                }
+            } else {
+                // Outside current viewport — skip.
+                while j < sorted.len() && sorted[j].0 == grid_line {
+                    if j > i && sorted[j].1 != sorted[j - 1].1 + 1 {
+                        break;
+                    }
+                    j += 1;
+                }
+            }
+
+            group_idx += 1;
+            i = j;
+        }
+
+        Some(map)
+    }
+
+    /// Render the search button (used in the tab bar).
+    pub(crate) fn render_search_button(
+        &self,
+        cx: &mut Context<Self>,
+    ) -> impl gpui::IntoElement {
+        // Wrap in a div so .hover() doesn't conflict with Button's internal hover.
+        div()
+            .child(
+                Button::new("search-btn")
+                    .ghost()
+                    .small()
+                    .rounded(px(999.))
+                    .icon(IconName::Search)
+                    .tooltip(t!("search").to_string())
+                    .on_click(cx.listener(|this, _, window, cx| {
+                        this.toggle_search(window, cx);
+                    })),
+            )
+    }
+
+    /// Render the expanded search bar overlay (when search is active).
+    pub(crate) fn render_search_bar(
+        &mut self,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> impl gpui::IntoElement {
+        let match_count = count_match_groups(&self.search_matches);
+        let has_query = !self.search_query.is_empty();
+        let has_matches = match_count > 0;
+        let current_display = if has_matches {
+            format!("{}/{}", self.search_current + 1, match_count)
+        } else if has_query {
+            "0".to_string()
+        } else {
+            String::new()
+        };
+
+        let view = cx.entity();
+        div()
+            .absolute()
+            .top(px(8.))
+            .right(px(24.))
+            .on_prepaint(move |bounds, _window, cx| {
+                let _ = view.update(cx, |this, _| {
+                    this.search_bar_bounds = Some(bounds);
+                });
+            })
+            .on_mouse_down(MouseButton::Left, cx.listener(|this, _, window, cx| {
+                this.refocus_search_input(window, cx);
+                cx.stop_propagation();
+            }))
+            .child(
+                h_flex()
+                    .gap_1()
+                    .items_center()
+                    .p_1()
+                    .rounded(px(6.))
+                    .bg(cx.theme().popover)
+                    .border_1()
+                    .border_color(cx.theme().border)
+                    .child(
+                        div()
+                            .w(px(200.))
+                            .on_key_down(cx.listener(|this, event: &gpui::KeyDownEvent, window, cx| {
+                                if event.keystroke.key.as_str() == "escape" {
+                                    this.close_search(window, cx);
+                                    window.prevent_default();
+                                    cx.stop_propagation();
+                                }
+                            }))
+                            .child(Input::new(&self.search_input).small()),
+                    )
+                    .when(!current_display.is_empty(), |this| {
+                        this.child(
+                            div()
+                                .text_size(rems(0.75))
+                                .text_color(cx.theme().muted_foreground)
+                                .min_w(px(36.))
+                                .text_center()
+                                .child(current_display),
+                        )
+                    })
+                    .child(
+                        Button::new("search-prev")
+                            .ghost()
+                            .xsmall()
+                            .icon(IconName::ChevronUp)
+                            .disabled(!has_matches)
+                            .on_click(cx.listener(|this, _, _, cx| {
+                                this.search_goto_prev(cx);
+                            })),
+                    )
+                    .child(
+                        Button::new("search-next")
+                            .ghost()
+                            .xsmall()
+                            .icon(IconName::ChevronDown)
+                            .disabled(!has_matches)
+                            .on_click(cx.listener(|this, _, _, cx| {
+                                this.search_goto_next(cx);
+                            })),
+                    )
+                    .child(
+                        Button::new("search-close")
+                            .ghost()
+                            .xsmall()
+                            .icon(IconName::Close)
+                            .on_click(cx.listener(|this, _, window, cx| {
+                                this.close_search(window, cx);
+                            })),
+                    ),
+            )
+            .into_any_element()
+    }
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────────
+
+/// Count distinct match groups in a sorted list of (row, col) positions.
+/// A group is a run of consecutive columns in the same row.
+fn count_match_groups(matches: &[(i32, i32)]) -> usize {
+    if matches.is_empty() {
+        return 0;
+    }
+    let mut sorted: Vec<(i32, i32)> = matches.to_vec();
+    sorted.sort();
+    let mut count = 0;
+    let mut i = 0;
+    while i < sorted.len() {
+        count += 1;
+        let (r, _) = sorted[i];
+        i += 1;
+        // Skip consecutive columns in the same row.
+        while i < sorted.len() && sorted[i].0 == r && sorted[i].1 == sorted[i - 1].1 + 1 {
+            i += 1;
+        }
+    }
+    count
+}
+
+/// Find the (row, col) start of the Nth distinct match group.
+fn find_nth_match_start(matches: &[(i32, i32)], n: usize) -> Option<(i32, i32)> {
+    if matches.is_empty() {
+        return None;
+    }
+    let mut sorted: Vec<(i32, i32)> = matches.to_vec();
+    sorted.sort();
+    let mut group_idx = 0;
+    let mut i = 0;
+    while i < sorted.len() {
+        if group_idx == n {
+            return Some(sorted[i]);
+        }
+        group_idx += 1;
+        let (r, _) = sorted[i];
+        i += 1;
+        while i < sorted.len() && sorted[i].0 == r && sorted[i].1 == sorted[i - 1].1 + 1 {
+            i += 1;
+        }
+    }
+    None
+}

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

@@ -9,6 +9,7 @@ pub(crate) const EMBEDDED_THEME_JSONS: &[&str] = &[
     include_str!("../../assets/themes/tokyonight.json"),
     include_str!("../../assets/themes/gruvbox.json"),
     include_str!("../../assets/themes/solarized.json"),
+    include_str!("../../assets/themes/phygerr.json"),
 ];
 
 pub(crate) fn load_fonts(cx: &mut App) -> Result<()> {

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

@@ -16,13 +16,13 @@ rust_i18n::i18n!("locales", fallback = "en");
 gpui::actions!(ashell_terminal, [TerminalTabKey, TerminalBacktabKey]);
 
 pub(crate) use app::keybinding_recorder::{
-    ClosePane, FocusPaneDown, FocusPaneLeft, FocusPaneRight, FocusPaneUp, NewSsh, OpenSession,
-    OpenSettings, OpenTransfers, SplitPaneDown, SplitPaneLeft, SplitPaneRight, SplitPaneUp,
-    ToggleSftpZoom, ToggleSidebar,
+    ClosePane, FocusPaneDown, FocusPaneLeft, FocusPaneRight, FocusPaneUp, NewSsh, OpenSearch,
+    OpenSession, OpenSettings, OpenTransfers, SplitPaneDown, SplitPaneLeft, SplitPaneRight,
+    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,7 +153,17 @@ pub enum TitleBarStyle {
     Integrated,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+#[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")]
     pub follow_system_theme: bool,
@@ -146,6 +181,8 @@ pub struct ConfigFile {
     pub ui_font_size: f32,
     #[serde(default)]
     pub right_click_copy_paste: bool,
+    #[serde(default)]
+    pub keyword_highlight: bool,
     #[serde(default = "default_ui_font_family")]
     pub ui_font_family: String,
     #[serde(default = "default_terminal_font_family")]
@@ -153,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>,
@@ -192,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 {
@@ -232,6 +293,53 @@ fn default_terminal_font_family() -> String {
     "Maple Mono NF CN".to_string()
 }
 
+impl Default for ConfigFile {
+    fn default() -> Self {
+        Self {
+            follow_system_theme: default_follow_system_theme(),
+            theme_mode: String::new(),
+            light_theme_name: String::new(),
+            dark_theme_name: String::new(),
+            locale: default_locale(),
+            terminal_font_size: default_terminal_font_size(),
+            ui_font_size: default_ui_font_size(),
+            right_click_copy_paste: false,
+            keyword_highlight: false,
+            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,
+            body_panels: None,
+            transfers: Vec::new(),
+            show_hidden_files: false,
+            monitoring_position: default_monitoring_position(),
+            sidebar_collapsed: false,
+            sftp_panel_minimized: false,
+            key_bindings: std::collections::HashMap::new(),
+            sync_endpoint: String::new(),
+            sync_username: String::new(),
+            sync_etag: None,
+            sync_device_id: String::new(),
+            sync_backend: String::new(),
+            sync_etag_backend: String::new(),
+            sync_s3_endpoint: String::new(),
+            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(),
+        }
+    }
+}
+
 pub struct ConfigStore {
     path: PathBuf,
     cache: ConfigFile,
@@ -534,6 +642,14 @@ impl ConfigStore {
         self.cache.right_click_copy_paste = val;
     }
 
+    pub fn keyword_highlight(&self) -> bool {
+        self.cache.keyword_highlight
+    }
+
+    pub fn set_keyword_highlight(&mut self, val: bool) {
+        self.cache.keyword_highlight = val;
+    }
+
     pub fn terminal_font_family(&self) -> &str {
         if self.cache.terminal_font_family.is_empty() {
             "Maple Mono NF CN"
@@ -554,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
     }
@@ -614,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
@@ -805,6 +863,15 @@ impl Ashell {
         window: &mut Window,
         cx: &mut Context<Self>,
     ) {
+        // If the search bar is visible and the click is inside it, let the
+        // search bar handle the event instead of switching pane focus.
+        if self.search_active {
+            if let Some(bounds) = self.search_bar_bounds {
+                if bounds.contains(&event.position) {
+                    return;
+                }
+            }
+        }
         self.focus_handle.focus(window, cx);
         // Check if click is in a different pane and focus it
         let click_pos = event.position;
@@ -823,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();
@@ -1052,7 +1131,16 @@ impl Ashell {
         if let Some(new_path) = Self::find_adjacent_pane(&self.pane_root, &path, direction) {
             self.focused_pane_path = new_path;
             if let Some(id) = self.pane_root.focused_tab_id(&self.focused_pane_path) {
-                self.active_tab = Some(id.to_string());
+                let id_owned = id.to_string();
+                let changed = self.active_tab.as_deref() != Some(id_owned.as_str());
+                self.active_tab = Some(id_owned);
+                // Clear stale search state when switching to a different pane.
+                if changed && self.search_active {
+                    self.search_query.clear();
+                    self.search_matches.clear();
+                    self.search_current = 0;
+                    self.search_target_tab = None;
+                }
             }
         }
     }
@@ -1335,8 +1423,17 @@ impl Ashell {
         }
         let mut path = Vec::new();
         if find_path(&self.pane_root, &tab_id, &mut path) {
+            let changed = self.active_tab.as_deref() != Some(tab_id.as_str());
             self.focused_pane_path = path;
             self.active_tab = Some(tab_id);
+            // Clear stale search state when switching to a different pane.
+            // The user can press Enter to re-search in the new pane.
+            if changed && self.search_active {
+                self.search_query.clear();
+                self.search_matches.clear();
+                self.search_current = 0;
+                self.search_target_tab = None;
+            }
         }
     }
 }

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

@@ -132,6 +132,7 @@ pub struct TerminalElement {
     font_size: Pixels,
     line_height: Pixels,
     cell_width: Pixels,
+    search_highlights: Option<std::collections::HashMap<(i32, i32), Hsla>>,
 }
 
 pub struct PrepaintState {
@@ -270,6 +271,7 @@ impl TerminalElement {
         font_size: Pixels,
         line_height: Pixels,
         cell_width: Pixels,
+        search_highlights: Option<std::collections::HashMap<(i32, i32), Hsla>>,
     ) -> Self {
         Self {
             view,
@@ -280,6 +282,7 @@ impl TerminalElement {
             font_size,
             line_height,
             cell_width,
+            search_highlights,
         }
     }
 
@@ -354,6 +357,12 @@ impl TerminalElement {
         let mut custom_blocks = Vec::new();
         let mut current_run: Option<BatchedTextRun> = None;
 
+        // Retrieve cached keyword highlights and merge with search highlights
+        let mut highlights = self.snapshot.highlights.clone();
+        if let Some(sm) = self.search_highlights.as_ref() {
+            highlights.extend(sm.iter().map(|(k, v)| (*k, *v)));
+        }
+
         for render_cell in &self.snapshot.cells {
             let cell = &render_cell.cell;
             if cell.flags.intersects(
@@ -392,7 +401,12 @@ impl TerminalElement {
                 continue;
             }
 
-            let style = self.cell_run_style(cell, cx);
+            let mut style = self.cell_run_style(cell, cx);
+
+            // Apply keyword highlight color if this cell was matched.
+            if let Some(&hl_color) = highlights.get(&(render_cell.row, render_cell.col)) {
+                style.color = hl_color;
+            }
 
             // Box Drawing & Block Elements interception
             let is_custom_block = is_custom_block_supported(cell.c);
@@ -450,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

@@ -0,0 +1,632 @@
+use std::collections::HashMap;
+use gpui::Hsla;
+use crate::terminal::RenderCell;
+
+trait HslaExt {
+    fn into_rgba_like(self, r: u8, g: u8, b: u8) -> Self;
+}
+
+impl HslaExt for Hsla {
+    fn into_rgba_like(self, r: u8, g: u8, b: u8) -> Self {
+        let rf = r as f32 / 255.0;
+        let gf = g as f32 / 255.0;
+        let bf = b as f32 / 255.0;
+        let max = rf.max(gf).max(bf);
+        let min = rf.min(gf).min(bf);
+        let l = (max + min) / 2.0;
+        if max == min {
+            return Hsla { h: 0.0, s: 0.0, l, a: 1.0 };
+        }
+        let d = max - min;
+        let s = if l > 0.5 { d / (2.0 - max - min) } else { d / (max + min) };
+        let h = if max == rf {
+            ((gf - bf) / d + if gf < bf { 6.0 } else { 0.0 }) / 6.0
+        } else if max == gf {
+            ((bf - rf) / d + 2.0) / 6.0
+        } else {
+            ((rf - gf) / d + 4.0) / 6.0
+        };
+        Hsla { h, s, l, a: 1.0 }
+    }
+}
+
+#[derive(Debug, Clone)]
+struct HighlightColors {
+    // 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 {
+    Hsla {
+        h: 0.0,
+        s: 0.0,
+        l: 0.0,
+        a: 1.0,
+    }
+    .into_rgba_like(r, g, b)
+}
+
+fn highlight_colors() -> HighlightColors {
+    HighlightColors {
+        // 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
+    }
+}
+
+/// 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(
+    cells: &[RenderCell],
+    rows: usize,
+) -> HashMap<(i32, i32), Hsla> {
+    let colors = highlight_colors();
+
+    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 {
+            continue;
+        }
+        row_chars[rc.row as usize].push((rc.col, rc.cell.c));
+    }
+    for row in row_chars.iter_mut() {
+        row.sort_by_key(|&(col, _)| col);
+    }
+
+    let mut map = HashMap::new();
+
+    let mut chars_buf = String::with_capacity(128);
+    let mut byte_to_col: Vec<i32> = Vec::with_capacity(128);
+
+    for (row_idx, row) in row_chars.iter().enumerate() {
+        if row.is_empty() {
+            continue;
+        }
+        let row_i32 = row_idx as i32;
+
+        chars_buf.clear();
+        byte_to_col.clear();
+
+        for &(col, c) in row {
+            chars_buf.push(c);
+            while byte_to_col.len() < chars_buf.len() {
+                byte_to_col.push(col);
+            }
+        }
+        let text = chars_buf.as_str();
+
+        // ── 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. Error keywords ──────────────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["ERROR", "ERR"], colors.error);
+
+        // ── 3. Alert ───────────────────────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["ALERT"], colors.alert);
+
+        // ── 4. Warning keywords ────────────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["WARNING", "WARN"], colors.warning);
+
+        // ── 5. Info keywords ───────────────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["INFO", "INFORMATION", "NOTICE"], colors.info);
+
+        // ── 6. Debug keywords ──────────────────────────────────
+        highlight_keywords(&mut map, text, &byte_to_col, row_i32,
+            &["DEBUG", "DBG", "TRACE"], colors.debug);
+
+        // ── 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 + 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);
+            }
+        }
+
+        // ── 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 - 1).min(byte_to_col.len() - 1)];
+            for c in start_col..=end_col {
+                map.entry((row_i32, c)).or_insert(colors.url);
+            }
+        }
+
+        // ── 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 - 1).min(byte_to_col.len() - 1)];
+            for c in start_col..=end_col {
+                map.entry((row_i32, c)).or_insert(colors.port);
+            }
+        }
+    }
+
+    map
+}
+
+fn find_ip_len(text: &str) -> usize {
+    let bytes = text.as_bytes();
+    let mut dots = 0u8;
+    let mut digits = 0u8;
+    let mut len = 0usize;
+
+    for &b in bytes {
+        match b {
+            b'0'..=b'9' => {
+                digits += 1;
+                if digits > 3 {
+                    return 0;
+                }
+            }
+            b'.' => {
+                if digits == 0 {
+                    return 0;
+                }
+                dots += 1;
+                if dots > 3 {
+                    return 0;
+                }
+                digits = 0;
+            }
+            _ => break, // Stop at first non-digit/non-dot (including '/')
+        }
+        len += 1;
+    }
+
+    if dots == 3 && digits > 0 {
+        len
+    } else {
+        0
+    }
+}
+
+fn find_ip_addresses(text: &str) -> Vec<usize> {
+    let mut positions = Vec::new();
+    let bytes = text.as_bytes();
+    let len = bytes.len();
+
+    for i in 0..len {
+        if bytes[i].is_ascii_digit()
+            && (i == 0 || is_boundary(bytes[i - 1] as char))
+        {
+            let remaining = &text[i..];
+            let ip_len = find_ip_len(remaining);
+            if ip_len > 0 {
+                let ip_str = &remaining[..ip_len];
+                let valid = ip_str
+                    .split('.')
+                    .all(|octet| octet.parse::<u8>().is_ok());
+                if valid {
+                    positions.push(i);
+                }
+            }
+        }
+    }
+    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;
+    while let Some(pos) = text[start..].find("http") {
+        let abs = start + pos;
+        let remaining = &text[abs..];
+        if remaining.starts_with("https://") || remaining.starts_with("http://") {
+            if abs == 0 || is_boundary(text.as_bytes()[abs - 1] as char) {
+                positions.push(abs);
+            }
+        }
+        start = abs + 4;
+    }
+    positions
+}
+
+fn find_url_len(text: &str) -> usize {
+    text.find(|c: char| c.is_ascii_whitespace())
+        .unwrap_or(text.len())
+}
+
+fn find_ports(text: &str) -> Vec<usize> {
+    let mut positions = Vec::new();
+    let bytes = text.as_bytes();
+    let len = bytes.len();
+
+    for i in 0..len {
+        if bytes[i] == b':'
+            && i + 1 < len
+            && bytes[i + 1].is_ascii_digit()
+            && (i == 0 || is_boundary(bytes[i - 1] as char) || bytes[i - 1] == b' ')
+        {
+            let mut j = i + 1;
+            while j < len && bytes[j].is_ascii_digit() {
+                j += 1;
+            }
+            let port_str = &text[i + 1..j];
+            if let Ok(port) = port_str.parse::<u16>() {
+                if port > 0 {
+                    let after_ok = j >= len || is_boundary(bytes[j] as char);
+                    if after_ok {
+                        positions.push(i);
+                    }
+                }
+            }
+        }
+    }
+    positions
+}
+
+fn find_port_len(text: &str) -> usize {
+    if !text.starts_with(':') {
+        return 0;
+    }
+    let mut len = 1;
+    for b in text.as_bytes()[1..].iter() {
+        if b.is_ascii_digit() {
+            len += 1;
+        } else {
+            break;
+        }
+    }
+    len
+}

src/terminal/input.rs

@@ -3,8 +3,8 @@ use std::ops::Range;
 use alacritty_terminal::index::Side;
 use alacritty_terminal::selection::SelectionType;
 use gpui::{
-    ClipboardItem, Context, KeyDownEvent, MouseButton, MouseDownEvent, MouseMoveEvent,
-    MouseUpEvent, Pixels, Point, ScrollDelta, ScrollWheelEvent, Window, px,
+    ClipboardItem, Context, Focusable as _, KeyDownEvent, MouseButton, MouseDownEvent,
+    MouseMoveEvent, MouseUpEvent, Pixels, Point, ScrollDelta, ScrollWheelEvent, Window, px,
 };
 
 use crate::{
@@ -12,6 +12,10 @@ use crate::{
     terminal::{BackendCommand, encode_key},
 };
 
+thread_local! {
+    static LAST_DRAG_SCROLL: std::cell::Cell<Option<std::time::Instant>> = std::cell::Cell::new(None);
+}
+
 impl Ashell {
     pub(crate) fn on_terminal_key_down(
         &mut self,
@@ -19,6 +23,17 @@ impl Ashell {
         window: &mut Window,
         cx: &mut Context<Self>,
     ) {
+        // If the search input is focused, skip terminal key processing
+        // so the input can handle text entry, paste, etc. normally.
+        if self
+            .search_input
+            .read(cx)
+            .focus_handle(cx)
+            .is_focused(window)
+        {
+            return;
+        }
+
         // Pane navigation: Alt + h/j/k/l
         if event.keystroke.modifiers.alt
             && !event.keystroke.modifiers.shift
@@ -97,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()
@@ -123,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();
@@ -161,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()
@@ -175,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;
         };
@@ -243,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();
     }
@@ -337,7 +374,54 @@ impl Ashell {
         let Some(active_id) = self.active_tab.clone() else {
             return;
         };
+        let snapshot = match self.active_snapshot() {
+            Some(s) => s,
+            None => return,
+        };
+        let max_row = snapshot.rows.saturating_sub(1);
+
+        let mut scroll_delta = 0i32;
+        if max_row >= 6 {
+            if row <= 2 || row >= max_row.saturating_sub(2) {
+                let now = std::time::Instant::now();
+                let should_scroll = LAST_DRAG_SCROLL.with(|last| {
+                    if let Some(last_time) = last.get() {
+                        if now.duration_since(last_time) >= std::time::Duration::from_millis(80) {
+                            last.set(Some(now));
+                            true
+                        } else {
+                            false
+                        }
+                    } else {
+                        last.set(Some(now));
+                        true
+                    }
+                });
+
+                if should_scroll {
+                    if row == 0 {
+                        scroll_delta = 2;
+                    } else if row == 1 {
+                        scroll_delta = 1;
+                    } else if row == 2 {
+                        scroll_delta = 1;
+                    } else if row == max_row {
+                        scroll_delta = -2;
+                    } else if row == max_row.saturating_sub(1) {
+                        scroll_delta = -1;
+                    } else if row == max_row.saturating_sub(2) {
+                        scroll_delta = -1;
+                    }
+                }
+            } else {
+                LAST_DRAG_SCROLL.with(|last| last.set(None));
+            }
+        }
+
         if let Some(tab) = self.tabs.iter_mut().find(|tab| tab.id == active_id) {
+            if scroll_delta != 0 {
+                tab.scroll_history(scroll_delta);
+            }
             tab.update_selection(row, col, side);
             cx.notify();
         }
@@ -455,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();
@@ -470,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

@@ -1,13 +1,14 @@
 pub mod custom_blocks;
 pub mod element;
 pub mod input;
+pub mod highlight;
 
 use std::sync::mpsc::Sender;
 
 use alacritty_terminal::{
     event::{Event, EventListener},
     grid::{Dimensions, Scroll},
-    index::{Column, Point, Side},
+    index::{Column, Line, Point, Side},
     selection::{Selection, SelectionRange, SelectionType},
     term::{Config, Term, TermMode, cell::Cell, point_to_viewport, viewport_to_point},
     vte::ansi::{CursorShape, Processor},
@@ -137,13 +138,22 @@ 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>)>>,
 }
 
 #[derive(Clone, Copy)]
@@ -153,7 +163,7 @@ pub struct CursorState {
     pub shape: CursorShape,
 }
 
-#[derive(Clone)]
+#[derive(Clone, PartialEq)]
 pub struct RenderCell {
     pub row: i32,
     pub col: i32,
@@ -169,6 +179,7 @@ pub struct RenderSnapshot {
     pub history_size: usize,
     pub rows: usize,
     pub cols: usize,
+    pub highlights: std::collections::HashMap<(i32, i32), gpui::Hsla>,
 }
 
 #[derive(Clone, Copy)]
@@ -238,19 +249,24 @@ 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),
         }
     }
 
@@ -258,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);
@@ -270,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 });
         }
     }
 
@@ -328,17 +360,72 @@ impl TerminalTab {
             });
         }
 
+        // Get highlights from cache or recompute, only if keyword_highlight is enabled.
+        let is_enabled = crate::session::config::ConfigStore::load()
+            .map(|c| c.keyword_highlight())
+            .unwrap_or(false);
+
+        let highlights = if is_enabled {
+            let mut cache = self.highlight_cache.borrow_mut();
+            let cache_valid = cache.as_ref().is_some_and(|(cached_cells, _)| {
+                cached_cells == &cells
+            });
+            if cache_valid {
+                cache.as_ref().unwrap().1.clone()
+            } else {
+                let computed = self::highlight::highlight_cells(&cells, rows as usize);
+                *cache = Some((cells.clone(), computed.clone()));
+                computed
+            }
+        } else {
+            std::collections::HashMap::new()
+        };
+
         RenderSnapshot {
             cells,
             cursor: self.cursor_state(),
-            selection: viewport_selection_from_range(content.display_offset, &content.selection),
+            selection: viewport_selection_from_range(
+                content.display_offset,
+                self.rows as usize,
+                self.cols as usize,
+                &content.selection,
+            ),
             display_offset: content.display_offset,
             history_size: self.term.grid().history_size(),
             rows: self.rows as usize,
             cols: self.cols as usize,
+            highlights,
         }
     }
 
+    /// Return `(grid_line_base, rows_data)` for the **entire** terminal buffer
+    /// including scrollback history. `grid_line_base` is the grid line index of
+    /// the first row (typically `-history_size`). Each entry in `rows_data` is
+    /// a sorted `Vec<(col, char)>` for that row.
+    pub fn full_grid_rows(&self) -> (i32, Vec<Vec<(i32, char)>>) {
+        let grid = self.term.grid();
+        let history = grid.history_size() as i32;
+        let screen = grid.screen_lines() as i32;
+        let total = history + screen;
+        let cols = self.cols as i32;
+        let start_line = -history;
+
+        let mut rows_data: Vec<Vec<(i32, char)>> = Vec::with_capacity(total as usize);
+        for line_idx in start_line..(start_line + total) {
+            let line = Line(line_idx);
+            let mut cells: Vec<(i32, char)> = Vec::new();
+            for col_idx in 0..cols {
+                let point = Point::new(line, Column(col_idx as usize));
+                let c = grid[point].c;
+                if c != ' ' && c != '\0' {
+                    cells.push((col_idx, c));
+                }
+            }
+            rows_data.push(cells);
+        }
+        (start_line, rows_data)
+    }
+
     pub fn scroll_history(&mut self, delta: i32) {
         if delta != 0 {
             self.term.scroll_display(Scroll::Delta(delta));
@@ -408,13 +495,14 @@ 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()));
     }
 }
 
 fn viewport_selection_from_range(
     display_offset: usize,
+    rows: usize,
+    cols: usize,
     selection: &Option<SelectionRange>,
 ) -> Option<ViewportSelection> {
     let SelectionRange {
@@ -422,14 +510,34 @@ fn viewport_selection_from_range(
         end,
         is_block,
     } = selection.as_ref().copied()?;
-    let start = point_to_viewport(display_offset, start)?;
-    let end = point_to_viewport(display_offset, end)?;
+
+    let top_point = viewport_to_point(display_offset, Point::new(0, Column(0)));
+    let bottom_point = viewport_to_point(display_offset, Point::new(rows.saturating_sub(1), Column(0)));
+
+    let top_line = top_point.line;
+    let bottom_line = bottom_point.line;
+
+    let start_vp = if start.line < top_line {
+        Point::new(0, Column(0))
+    } else if start.line > bottom_line {
+        Point::new(rows.saturating_sub(1), Column(cols.saturating_sub(1)))
+    } else {
+        point_to_viewport(display_offset, start).unwrap_or(Point::new(0, Column(0)))
+    };
+
+    let end_vp = if end.line < top_line {
+        Point::new(0, Column(0))
+    } else if end.line > bottom_line {
+        Point::new(rows.saturating_sub(1), Column(cols.saturating_sub(1)))
+    } else {
+        point_to_viewport(display_offset, end).unwrap_or(Point::new(rows.saturating_sub(1), Column(cols.saturating_sub(1))))
+    };
 
     Some(ViewportSelection {
-        start_row: start.line,
-        start_col: start.column.0,
-        end_row: end.line,
-        end_col: end.column.0,
+        start_row: start_vp.line,
+        start_col: start_vp.column.0,
+        end_row: end_vp.line,
+        end_col: end_vp.column.0,
         is_block,
     })
 }
@@ -437,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,
@@ -454,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 {
@@ -471,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> {