Added default update server

Cargo.lock

@@ -1123,7 +1123,7 @@ dependencies = [
 
 [[package]]
 name = "ostiary"
-version = "1.1.0"
+version = "1.0.8"
 dependencies = [
  "anyhow",
  "crossterm",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ostiary"
-version = "1.1.0"
+version = "1.0.9"
 edition = "2024"
 
 [dependencies]

README.md

@@ -9,7 +9,7 @@
 ### Быстрая установка (Linux / macOS)
 
 ```bash
-curl -fsSL https://vainend.com/ostiary | bash
+curl -fsSL https://git.vainend.com/admin/ostiary/raw/branch/master/install.sh | bash
 ```
 
 Скрипт определяет ОС и архитектуру, скачивает последний стабильный релиз и устанавливает бинарник в `~/.local/bin/ostiary`. Если этого пути нет в `$PATH` — автоматически добавляет строку в `~/.bashrc` (или `~/.bash_profile` / `~/.profile`). Не требует `sudo`.
@@ -38,7 +38,7 @@ source ~/.bashrc
 ### Удаление
 
 ```bash
-curl -fsSL https://vainend.com/ostiary-remove | bash
+curl -fsSL https://git.vainend.com/admin/ostiary/raw/branch/master/uninstall.sh | bash
 ```
 
 Или вручную:
@@ -75,14 +75,13 @@ INSTALL_DIR=~/.local/bin bash install.sh
 
 ### Popup запущенного скрипта
 
-| Клавиша | Контекст | Действие |
+| Клавиша | Действие |
-|---|---|---|
+|---|---|
-| `↑` / `↓` или `k` / `j` | Лог / селектор / форма | Прокрутка лога или навигация между элементами |
+| `↑` / `↓` или `k` / `j` | Прокрутка лога / навигация по селектору |
-| `PgUp` / `PgDn` | Лог | Прокрутка на 10 строк |
+| `PgUp` / `PgDn` | Прокрутка лога на 10 строк |
-| `Space` | Форма | Переключить чекбокс / выбрать радиокнопку |
+| `Y` / `N` или `l` / `h` | Ответ на подтверждение (без Enter) |
-| `Y` / `N` или `l` / `h` | Подтверждение | Ответ без Enter |
+| `Enter` или `l` | Выбрать пункт селектора / подтвердить |
-| `Enter` или `l` | Любой ввод | Отправить / выбрать / применить форму |
+| `Esc` или `h` | Прервать скрипт и закрыть popup |
-| `Esc` или `h` | — | Прервать скрипт и закрыть popup |
 
 > Vim-motions (`j`/`k`/`l`/`h`) отключаются автоматически во время текстового ввода — символы идут в поле ввода как обычно.
 
@@ -432,48 +431,6 @@ notify '{"type":"progress","percent":100,"message":"Готово!"}'
 
 ---
 
-### Форма с чекбоксами и радиокнопками (`form`)
-
-Отображает список полей с возможностью навигации и переключения. Возвращает строку с ID всех включённых/выбранных полей через пробел.
-
-```json
-{
-  "type": "form",
-  "prompt": "Параметры поиска:",
-  "fields": [
-    {"id": "verbose",  "label": "Подробный вывод",   "field_type": "checkbox", "default": false},
-    {"id": "php",      "label": "PHP файлы (*.php)",  "field_type": "radio",    "group": "ftype", "default": true},
-    {"id": "js",       "label": "JS файлы (*.js)",    "field_type": "radio",    "group": "ftype", "default": false}
-  ]
-}
-```
-
-| Поле | Описание |
-|---|---|
-| `id` | Идентификатор, возвращается если поле включено |
-| `label` | Отображаемый текст |
-| `field_type` | `"checkbox"` или `"radio"` |
-| `default` | Начальное состояние |
-| `group` | Группа радиокнопок — одновременно активна только одна в группе |
-
-**Ответ:** строка с ID активных полей через пробел: `"verbose php"`
-
-**Клавиши внутри формы:** `↑`/`↓`/`j`/`k` — навигация, `Space` — переключить, `Enter`/`l` — применить, `Esc` — отмена.
-
-**Важно:** весь JSON должен быть на **одной строке** — протокол читает строки, не блоки.
-
-```bash
-result=$(ask '{"type":"form","prompt":"Параметры:","fields":[{"id":"verbose","label":"Подробный вывод","field_type":"checkbox","default":false},{"id":"php","label":"PHP файлы","field_type":"radio","group":"t","default":true},{"id":"js","label":"JS файлы","field_type":"radio","group":"t","default":false}]}')
-
-is_on() { [[ " $result " == *" $1 "* ]]; }
-
-is_on "verbose" && FLAGS+=("-v")
-is_on "php"     && INCLUDE="--include=*.php"
-is_on "js"      && INCLUDE="--include=*.js"
-```
-
----
-
 ### Запуск внешнего приложения (`exec`)
 
 Временно **передаёт терминал** внешней программе (mysql, vim, htop и др.). Клиент скрывает TUI, программа работает на полном экране, после завершения TUI восстанавливается. Возвращает код завершения.

src/app.rs

@@ -1,11 +1,11 @@
+// src/app.rs
 use crate::config::Config;
 use crate::error::Result;
 use crate::executor;
 use crate::menu::{Action, InteractionMode, MenuItem, MenuItemKind, MenuRoot};
 use crate::network;
-use crate::text_input::TextInput;
 use crate::updater;
-use crossterm::event::{Event as CrosstermEvent, KeyCode, KeyEventKind, KeyModifiers};
+use crossterm::event::{Event as CrosstermEvent, KeyCode, KeyEventKind};
 use tokio::sync::mpsc::UnboundedSender;
 
 #[derive(Debug)]
@@ -25,6 +25,7 @@ pub enum Event {
 }
 
 /// A pending request to hand the terminal to an external interactive process.
+/// Set by the structured-protocol handler; consumed by the main event loop.
 pub struct PendingExec {
     pub shell: String,
     pub reply_tx: tokio::sync::mpsc::UnboundedSender<String>,
@@ -36,10 +37,11 @@ pub struct App {
     pub error: Option<String>,
     pub breadcrumbs: Vec<usize>,
     pub selected_index: usize,
-    pub menu_scroll_offset: usize,
     pub popup: Option<Popup>,
     pub event_tx: UnboundedSender<Event>,
+    /// When set, main loop suspends ratatui, runs the command, then restores.
     pub pending_exec: Option<PendingExec>,
+    /// Exe path to exec after update; captured before the binary was replaced.
     pub pending_restart: Option<std::path::PathBuf>,
 }
 
@@ -52,35 +54,20 @@ pub enum Popup {
     ExecutingBashTerminal { child: tokio::process::Child },
     ExecutingStructured {
         reply_tx: tokio::sync::mpsc::UnboundedSender<String>,
+        /// Fires SIGTERM to the script's process group on Esc.
         kill_tx: Option<tokio::sync::oneshot::Sender<()>>,
         log_buffer: Vec<String>,
         current_command: Option<executor::StructuredCommand>,
-        input: TextInput,
+        input_buffer: String,
+        /// Cursor position for Menu-type commands.
         menu_selected_index: usize,
-        form_cursor: usize,
+        /// Index of the first visible line in log_buffer (0 = top of output).
-        form_values: Vec<bool>,
         log_scroll_pos: usize,
-        log_scroll_x: usize,
+        /// When true, keep position pinned to the bottom as new output arrives.
         log_follow_bottom: bool,
+        /// Set when the process has exited; popup stays open until Esc.
         finished: Option<i32>,
     },
-    EndpointSelector {
-        selected: usize,
-        scroll_offset: usize,
-    },
-    /// Unified add/edit popup. `edit_index = None` → adding new endpoint.
-    UpsertEndpoint {
-        edit_index: Option<usize>,
-        /// [0] = name, [1] = url
-        fields: [TextInput; 2],
-        active_field: usize,
-        error: Option<String>,
-        return_selected: usize,
-    },
-    ConfirmDeleteEndpoint {
-        index: usize,
-        return_selected: usize,
-    },
     Downloading { progress: f32, message: String },
     Message { text: String, level: MessageLevel },
     UpdateConfirm {
@@ -116,7 +103,6 @@ impl App {
             error: None,
             breadcrumbs: Vec::new(),
             selected_index: 0,
-            menu_scroll_offset: 0,
             popup: None,
             event_tx,
             pending_exec: None,
@@ -140,7 +126,7 @@ impl App {
     }
 
     pub async fn load_menu(&mut self) {
-        let server_url = self.config.active_url().to_string();
+        let server_url = self.config.server_url.clone();
         let timeout = self.config.timeout_sec;
         let tx = self.event_tx.clone();
 
@@ -195,6 +181,9 @@ impl App {
                 Ok(false)
             }
             Event::StructuredCommand(cmd) => {
+                // Exec hands the terminal to an external process — clone reply_tx,
+                // store as pending_exec, and skip setting current_command so the
+                // main loop can suspend ratatui immediately.
                 if let executor::StructuredCommand::Exec { shell } = &cmd {
                     if let Some(Popup::ExecutingStructured { reply_tx, .. }) = &self.popup {
                         self.pending_exec = Some(PendingExec {
@@ -208,50 +197,41 @@ impl App {
                 if let Some(Popup::ExecutingStructured {
                     current_command,
                     menu_selected_index,
-                    form_cursor,
-                    form_values,
                     ..
                 }) = &mut self.popup
                 {
-                    match &cmd {
+                    if matches!(cmd, executor::StructuredCommand::Menu { .. }) {
-                        executor::StructuredCommand::Menu { .. } => {
+                        *menu_selected_index = 0;
-                            *menu_selected_index = 0;
-                        }
-                        executor::StructuredCommand::Form { fields, .. } => {
-                            *form_cursor = 0;
-                            *form_values = fields.iter().map(|f| f.default).collect();
-                        }
-                        _ => {}
                     }
                     *current_command = Some(cmd);
                 }
                 Ok(false)
             }
             Event::StructuredOutput(line) => {
-                if let Some(Popup::ExecutingStructured { log_buffer, .. }) = &mut self.popup {
+                if let Some(Popup::ExecutingStructured {
+                    log_buffer,
+                    log_follow_bottom,
+                    log_scroll_pos,
+                    ..
+                }) = &mut self.popup
+                {
                     log_buffer.push(line);
+                    // log_follow_bottom: render will pin pos to bottom.
+                    // Otherwise pos stays fixed → new line appears off-screen.
+                    let _ = (log_follow_bottom, log_scroll_pos); // used by render
                 }
                 Ok(false)
             }
             Event::StructuredFinished(exit_code) => {
-                if let Some(Popup::ExecutingStructured {
+                if let Some(Popup::ExecutingStructured { finished, .. }) = &mut self.popup {
-                    finished,
-                    current_command,
-                    ..
-                }) = &mut self.popup
-                {
                     *finished = Some(exit_code);
-                    if matches!(
-                        current_command,
-                        Some(executor::StructuredCommand::Progress { .. })
-                            | Some(executor::StructuredCommand::Message { .. })
-                    ) {
-                        *current_command = None;
-                    }
                 }
+                // If popup was already closed (user pressed Esc to kill the
+                // script), we silently discard the exit event.
                 Ok(false)
             }
             Event::UpdateAvailable(info) => {
+                // Only show if no popup is currently open (don't interrupt running scripts)
                 if self.popup.is_none() {
                     self.popup = Some(Popup::UpdateConfirm { info });
                 }
@@ -302,16 +282,13 @@ impl App {
                         Popup::ExecutingStructured {
                             reply_tx,
                             kill_tx,
-                            input,
+                            input_buffer,
                             current_command,
                             menu_selected_index,
-                            form_cursor,
-                            form_values,
                             log_scroll_pos,
-                            log_scroll_x,
                             log_follow_bottom,
                             log_buffer,
-                            finished: _,
+                            finished,
                         } => {
                             let is_menu = matches!(
                                 current_command,
@@ -321,156 +298,106 @@ impl App {
                                 current_command,
                                 Some(executor::StructuredCommand::Confirm { .. })
                             );
-                            let is_form = matches!(
+                            let has_command = current_command.is_some();
-                                current_command,
+                            // Vim motions are disabled only when free text input is active.
-                                Some(executor::StructuredCommand::Form { .. })
-                            );
-                            let blocks_scroll = matches!(
-                                current_command,
-                                Some(executor::StructuredCommand::Input { .. })
-                                    | Some(executor::StructuredCommand::Menu { .. })
-                                    | Some(executor::StructuredCommand::Confirm { .. })
-                                    | Some(executor::StructuredCommand::Form { .. })
-                            );
                             let is_text_input = matches!(
                                 current_command,
                                 Some(executor::StructuredCommand::Input { .. })
                             );
-                            let alt = key.modifiers.intersects(KeyModifiers::ALT | KeyModifiers::SUPER);
 
                             match key.code {
-                                // ── Log scrolling ────────────────────────────────
+                                // ── Log scrolling (PageUp / PageDown always work) ─
                                 KeyCode::PageUp => {
                                     *log_scroll_pos = log_scroll_pos.saturating_sub(10);
                                     *log_follow_bottom = false;
                                 }
                                 KeyCode::PageDown => {
                                     *log_scroll_pos = log_scroll_pos.saturating_add(10);
-                                    *log_follow_bottom = *log_scroll_pos + 1 >= log_buffer.len();
+                                    // Render will clamp to max; if we're at the
+                                    // bottom, mark as following.
+                                    *log_follow_bottom =
+                                        *log_scroll_pos + 1 >= log_buffer.len();
                                 }
 
-                                // ── Form navigation ──────────────────────────────
+                                // ── Arrow keys ────────────────────────────────────
-                                KeyCode::Up if is_form => {
+                                KeyCode::Up if is_menu => {
-                                    if *form_cursor > 0 { *form_cursor -= 1; }
+                                    if *menu_selected_index > 0 {
-                                }
+                                        *menu_selected_index -= 1;
-                                KeyCode::Down if is_form => {
-                                    let len = if let Some(executor::StructuredCommand::Form { fields, .. }) = current_command {
-                                        fields.len()
-                                    } else { 0 };
-                                    if *form_cursor + 1 < len { *form_cursor += 1; }
-                                }
-                                KeyCode::Char(' ') if is_form => {
-                                    let cursor = *form_cursor;
-                                    let toggle = if let Some(executor::StructuredCommand::Form { fields, .. }) = current_command {
-                                        fields.get(cursor).map(|f| {
-                                            let group_indices: Vec<usize> = fields.iter()
-                                                .enumerate()
-                                                .filter(|(_, ff)| ff.group.is_some() && ff.group == f.group)
-                                                .map(|(i, _)| i)
-                                                .collect();
-                                            (f.field_type.clone(), group_indices)
-                                        })
-                                    } else { None };
-
-                                    if let Some((ftype, group_indices)) = toggle {
-                                        match ftype {
-                                            executor::FormFieldType::Checkbox => {
-                                                if let Some(v) = form_values.get_mut(cursor) {
-                                                    *v = !*v;
-                                                }
-                                            }
-                                            executor::FormFieldType::Radio => {
-                                                for i in group_indices {
-                                                    if let Some(v) = form_values.get_mut(i) {
-                                                        *v = i == cursor;
-                                                    }
-                                                }
-                                            }
-                                        }
                                     }
                                 }
-
-                                // ── Arrow / cursor keys ──────────────────────────
-                                KeyCode::Up if is_menu => {
-                                    if *menu_selected_index > 0 { *menu_selected_index -= 1; }
-                                }
                                 KeyCode::Down if is_menu => {
-                                    if let Some(executor::StructuredCommand::Menu { options, .. }) = current_command {
+                                    if let Some(executor::StructuredCommand::Menu {
+                                        options, ..
+                                    }) = current_command
+                                    {
                                         if *menu_selected_index + 1 < options.len() {
                                             *menu_selected_index += 1;
                                         }
                                     }
                                 }
-                                KeyCode::Up if !blocks_scroll => {
+                                // Scroll log one line when no interactive command pending
+                                KeyCode::Up if !has_command => {
                                     *log_scroll_pos = log_scroll_pos.saturating_sub(1);
                                     *log_follow_bottom = false;
                                 }
-                                KeyCode::Down if !blocks_scroll => {
+                                KeyCode::Down if !has_command => {
                                     *log_scroll_pos = log_scroll_pos.saturating_add(1);
-                                    *log_follow_bottom = *log_scroll_pos + 1 >= log_buffer.len();
+                                    *log_follow_bottom =
-                                }
+                                        *log_scroll_pos + 1 >= log_buffer.len();
-                                KeyCode::Left if is_text_input && alt => { input.word_back(); }
-                                KeyCode::Right if is_text_input && alt => { input.word_fwd(); }
-                                KeyCode::Left if is_text_input => { input.move_left(); }
-                                KeyCode::Right if is_text_input => { input.move_right(); }
-                                KeyCode::Left if !is_text_input && !is_menu && !is_form => {
-                                    *log_scroll_x = log_scroll_x.saturating_sub(4);
-                                }
-                                KeyCode::Right if !is_text_input && !is_menu && !is_form => {
-                                    *log_scroll_x = log_scroll_x.saturating_add(4);
                                 }
 
-                                // ── Confirm shortcuts ────────────────────────────
+                                // ── Confirm shortcuts (immediate, no Enter needed) ─
                                 KeyCode::Char('y') | KeyCode::Char('Y') if is_confirm => {
                                     let _ = current_command.take();
                                     let _ = reply_tx.send("y".to_string());
-                                    input.clear();
+                                    input_buffer.clear();
                                 }
                                 KeyCode::Char('n') | KeyCode::Char('N') if is_confirm => {
                                     let _ = current_command.take();
                                     let _ = reply_tx.send("n".to_string());
-                                    input.clear();
+                                    input_buffer.clear();
                                 }
 
-                                // ── Text input ───────────────────────────────────
+                                // ── Text input ────────────────────────────────────
-                                KeyCode::Char('b') if is_text_input && alt => { input.word_back(); }
+                                // Vim motion keys (j/k/l/h) are excluded here so they
-                                KeyCode::Char('f') if is_text_input && alt => { input.word_fwd(); }
+                                // fall through to the vim-motion arms below.
                                 KeyCode::Char(c)
-                                    if !is_menu && !is_confirm && !is_form
+                                    if !is_menu
-                                        && (is_text_input || !matches!(c, 'j' | 'k' | 'l' | 'h' | 'd' | 'u')) =>
+                                        && !is_confirm
+                                        && (is_text_input
+                                            || !matches!(c, 'j' | 'k' | 'l' | 'h')) =>
                                 {
-                                    input.insert(c);
+                                    input_buffer.push(c);
+                                }
+                                KeyCode::Backspace if !is_menu => {
+                                    input_buffer.pop();
                                 }
-                                KeyCode::Backspace if is_text_input && alt => { input.word_delete_back(); }
-                                KeyCode::Backspace if !is_menu && !is_form => { input.backspace(); }
 
-                                // ── Enter ────────────────────────────────────────
+                                // ── Enter: commit response ────────────────────────
                                 KeyCode::Enter => {
-                                    if is_form {
+                                    if let Some(cmd) = current_command.take() {
-                                        if let Some(executor::StructuredCommand::Form { fields, .. }) = current_command.take() {
-                                            let response = fields.iter().enumerate()
-                                                .filter_map(|(i, f)| {
-                                                    form_values.get(i).copied().filter(|&v| v).map(|_| f.id.as_str())
-                                                })
-                                                .collect::<Vec<_>>()
-                                                .join(" ");
-                                            let _ = reply_tx.send(response);
-                                            form_values.clear();
-                                            *form_cursor = 0;
-                                        }
-                                    } else if let Some(cmd) = current_command.take() {
                                         let response = match &cmd {
-                                            executor::StructuredCommand::Input { .. } => input.buf.clone(),
+                                            executor::StructuredCommand::Input { .. } => {
+                                                input_buffer.clone()
+                                            }
                                             executor::StructuredCommand::Confirm { .. } => {
-                                                if input.buf.to_lowercase().starts_with('y') { "y".to_string() } else { "n".to_string() }
+                                                if input_buffer.to_lowercase().starts_with('y') {
-                                            }
+                                                    "y".to_string()
-                                            executor::StructuredCommand::Menu { options, .. } => {
+                                                } else {
-                                                options.get(*menu_selected_index).map(|o| o.id.clone()).unwrap_or_default()
+                                                    "n".to_string()
+                                                }
                                             }
+                                            executor::StructuredCommand::Menu {
+                                                options, ..
+                                            } => options
+                                                .get(*menu_selected_index)
+                                                .map(|opt| opt.id.clone())
+                                                .unwrap_or_default(),
+                                            // Message / Progress: send empty ack.
                                             _ => String::new(),
                                         };
                                         let _ = reply_tx.send(response);
-                                        input.clear();
+                                        input_buffer.clear();
                                         *menu_selected_index = 0;
                                     }
                                 }
@@ -488,286 +415,66 @@ impl App {
                                     }
                                 }
 
-                                // ── Vim motions ──────────────────────────────────
+                                // ── Vim motions (off during text input) ───────────
                                 KeyCode::Char('k') if !is_text_input => {
                                     if is_menu {
-                                        if *menu_selected_index > 0 { *menu_selected_index -= 1; }
+                                        if *menu_selected_index > 0 {
-                                    } else if is_form {
+                                            *menu_selected_index -= 1;
-                                        if *form_cursor > 0 { *form_cursor -= 1; }
+                                        }
-                                    } else if !blocks_scroll {
+                                    } else if !has_command {
                                         *log_scroll_pos = log_scroll_pos.saturating_sub(1);
                                         *log_follow_bottom = false;
                                     }
                                 }
                                 KeyCode::Char('j') if !is_text_input => {
                                     if is_menu {
-                                        if let Some(executor::StructuredCommand::Menu { options, .. }) = current_command {
+                                        if let Some(executor::StructuredCommand::Menu {
+                                            options, ..
+                                        }) = current_command
+                                        {
                                             if *menu_selected_index + 1 < options.len() {
                                                 *menu_selected_index += 1;
                                             }
                                         }
-                                    } else if is_form {
+                                    } else if !has_command {
-                                        let len = if let Some(executor::StructuredCommand::Form { fields, .. }) = current_command {
-                                            fields.len()
-                                        } else { 0 };
-                                        if *form_cursor + 1 < len { *form_cursor += 1; }
-                                    } else if !blocks_scroll {
                                         *log_scroll_pos = log_scroll_pos.saturating_add(1);
-                                        *log_follow_bottom = *log_scroll_pos + 1 >= log_buffer.len();
+                                        *log_follow_bottom =
+                                            *log_scroll_pos + 1 >= log_buffer.len();
                                     }
                                 }
                                 KeyCode::Char('l') if !is_text_input => {
-                                    if is_form {
+                                    // Forward / confirm — same logic as Enter.
-                                        if let Some(executor::StructuredCommand::Form { fields, .. }) = current_command.take() {
+                                    if let Some(cmd) = current_command.take() {
-                                            let response = fields.iter().enumerate()
-                                                .filter_map(|(i, f)| {
-                                                    form_values.get(i).copied().filter(|&v| v).map(|_| f.id.as_str())
-                                                })
-                                                .collect::<Vec<_>>().join(" ");
-                                            let _ = reply_tx.send(response);
-                                            form_values.clear();
-                                            *form_cursor = 0;
-                                        }
-                                    } else if let Some(cmd) = current_command.take() {
                                         let response = match &cmd {
-                                            executor::StructuredCommand::Confirm { .. } => "y".to_string(),
+                                            executor::StructuredCommand::Confirm { .. } => {
-                                            executor::StructuredCommand::Menu { options, .. } => {
+                                                "y".to_string()
-                                                options.get(*menu_selected_index).map(|o| o.id.clone()).unwrap_or_default()
                                             }
+                                            executor::StructuredCommand::Menu {
+                                                options, ..
+                                            } => options
+                                                .get(*menu_selected_index)
+                                                .map(|o| o.id.clone())
+                                                .unwrap_or_default(),
                                             _ => String::new(),
                                         };
                                         let _ = reply_tx.send(response);
-                                        input.clear();
+                                        input_buffer.clear();
                                         *menu_selected_index = 0;
-                                    } else {
-                                        *log_scroll_x = log_scroll_x.saturating_add(4);
                                     }
                                 }
                                 KeyCode::Char('h') if !is_text_input => {
+                                    // Back / cancel — same logic as Esc.
                                     if is_confirm {
                                         let _ = current_command.take();
                                         let _ = reply_tx.send("n".to_string());
-                                    } else if !is_menu && !is_form {
-                                        *log_scroll_x = log_scroll_x.saturating_sub(4);
-                                    }
-                                }
-                                KeyCode::Char('H') if !is_text_input && !is_menu && !is_form => {
-                                    *log_scroll_x = 0;
-                                }
-                                KeyCode::Char('L') if !is_text_input && !is_menu && !is_form => {
-                                    *log_scroll_x = usize::MAX;
-                                }
-                                KeyCode::Char('d') if !is_text_input && !is_form => {
-                                    *log_scroll_pos = log_scroll_pos.saturating_add(10);
-                                    *log_follow_bottom = *log_scroll_pos + 1 >= log_buffer.len();
-                                }
-                                KeyCode::Char('u') if !is_text_input && !is_form => {
-                                    *log_scroll_pos = log_scroll_pos.saturating_sub(10);
-                                    *log_follow_bottom = false;
-                                }
-
-                                _ => {}
-                            }
-                            return Ok(false);
-                        }
-
-                        Popup::EndpointSelector { selected, scroll_offset: _ } => {
-                            match key.code {
-                                KeyCode::Up | KeyCode::Char('k') => {
-                                    if *selected > 0 { *selected -= 1; }
-                                }
-                                KeyCode::Down | KeyCode::Char('j') => {
-                                    let len = self.config.endpoints.len();
-                                    if *selected + 1 < len { *selected += 1; }
-                                }
-                                KeyCode::Enter | KeyCode::Char('l') => {
-                                    let sel = *selected;
-                                    self.popup = None;
-                                    let url = self.config.endpoints.get(sel).map(|ep| ep.url.clone());
-                                    if let Some(url) = url {
-                                        if url != self.config.active_endpoint {
-                                            self.config.active_endpoint = url;
-                                            let _ = self.config.save();
-                                            self.menu = None;
-                                            self.breadcrumbs.clear();
-                                            self.selected_index = 0;
-                                            self.menu_scroll_offset = 0;
-                                            self.load_menu().await;
-                                        }
-                                    }
-                                }
-                                KeyCode::Char('d') | KeyCode::Char('D') => {
-                                    let sel = *selected;
-                                    if sel < self.config.endpoints.len() {
-                                        self.popup = Some(Popup::ConfirmDeleteEndpoint {
-                                            index: sel,
-                                            return_selected: sel,
-                                        });
-                                    }
-                                }
-                                KeyCode::Char('e') | KeyCode::Char('E') => {
-                                    let sel = *selected;
-                                    if let Some(ep) = self.config.endpoints.get(sel) {
-                                        let name = ep.name.clone();
-                                        let url = ep.url.clone();
-                                        self.popup = Some(Popup::UpsertEndpoint {
-                                            edit_index: Some(sel),
-                                            fields: [TextInput::with_text(name), TextInput::with_text(url)],
-                                            active_field: 0,
-                                            error: None,
-                                            return_selected: sel,
-                                        });
-                                    }
-                                }
-                                KeyCode::Char('n') | KeyCode::Char('N') => {
-                                    let sel = *selected;
-                                    self.popup = Some(Popup::UpsertEndpoint {
-                                        edit_index: None,
-                                        fields: [TextInput::new(), TextInput::new()],
-                                        active_field: 0,
-                                        error: None,
-                                        return_selected: sel,
-                                    });
-                                }
-                                KeyCode::Esc | KeyCode::Tab => {
-                                    self.popup = None;
-                                }
-                                _ => {}
-                            }
-                            return Ok(false);
-                        }
-
-                        Popup::UpsertEndpoint {
-                            edit_index,
-                            fields,
-                            active_field,
-                            error,
-                            return_selected,
-                        } => {
-                            match key.code {
-                                KeyCode::Enter => {
-                                    if *active_field == 0 {
-                                        let name = fields[0].buf.trim().to_string();
-                                        let edit_idx = *edit_index;
-                                        if name.is_empty() {
-                                            *error = Some("Название не может быть пустым".to_string());
-                                        } else if let Some(conflict_url) = self.config.endpoints.iter()
-                                            .enumerate()
-                                            .find(|(i, ep)| Some(*i) != edit_idx && ep.name == name)
-                                            .map(|(_, ep)| ep.url.clone())
-                                        {
-                                            *error = Some(format!(
-                                                "Название \"{}\" уже используется для {}",
-                                                name, conflict_url
-                                            ));
-                                        } else {
-                                            fields[0].buf = name;
-                                            *active_field = 1;
-                                            *error = None;
-                                        }
                                     } else {
-                                        let url = fields[1].buf.trim().to_string();
+                                        if let Some(kx) = kill_tx.take() {
-                                        let name = fields[0].buf.trim().to_string();
+                                            let _ = kx.send(());
-                                        let edit_idx = *edit_index;
-                                        let ret = *return_selected;
-                                        if url.is_empty() {
-                                            *error = Some("URL не может быть пустым".to_string());
-                                        } else if let Some(conflict_name) = self.config.endpoints.iter()
-                                            .enumerate()
-                                            .find(|(i, ep)| Some(*i) != edit_idx && ep.url == url)
-                                            .map(|(_, ep)| ep.name.clone())
-                                        {
-                                            *error = Some(format!(
-                                                "URL уже используется для эндпоинта \"{}\"",
-                                                conflict_name
-                                            ));
-                                        } else {
-                                            match edit_idx {
-                                                None => {
-                                                    self.config.endpoints.push(crate::config::Endpoint { name, url });
-                                                    let _ = self.config.save();
-                                                    let new_sel = self.config.endpoints.len() - 1;
-                                                    self.popup = Some(Popup::EndpointSelector {
-                                                        selected: new_sel,
-                                                        scroll_offset: ret,
-                                                    });
-                                                }
-                                                Some(idx) => {
-                                                    let was_active = self.config.endpoints
-                                                        .get(idx)
-                                                        .map(|ep| ep.url == self.config.active_endpoint)
-                                                        .unwrap_or(false);
-                                                    if let Some(ep) = self.config.endpoints.get_mut(idx) {
-                                                        ep.name = name;
-                                                        ep.url = url.clone();
-                                                    }
-                                                    if was_active {
-                                                        self.config.active_endpoint = url;
-                                                    }
-                                                    let _ = self.config.save();
-                                                    self.popup = Some(Popup::EndpointSelector {
-                                                        selected: ret,
-                                                        scroll_offset: 0,
-                                                    });
-                                                }
-                                            }
                                         }
+                                        self.popup = None;
                                     }
                                 }
-                                KeyCode::Esc => {
-                                    let ret = *return_selected;
-                                    self.popup = Some(Popup::EndpointSelector {
-                                        selected: ret,
-                                        scroll_offset: 0,
-                                    });
-                                }
-                                _ => {
-                                    let af = *active_field;
-                                    if fields[af].handle_key(&key) {
-                                        *error = None;
-                                    }
-                                }
-                            }
-                            return Ok(false);
-                        }
 
-                        Popup::ConfirmDeleteEndpoint { index, return_selected } => {
-                            match key.code {
-                                KeyCode::Char('y') | KeyCode::Char('Y') => {
-                                    let idx = *index;
-                                    let ret = *return_selected;
-                                    self.popup = None;
-                                    if idx < self.config.endpoints.len() {
-                                        let was_active = self.config.endpoints[idx].url == self.config.active_endpoint;
-                                        self.config.endpoints.remove(idx);
-                                        let _ = self.config.save();
-                                        if self.config.endpoints.is_empty() {
-                                            self.config.active_endpoint = String::new();
-                                            self.menu = None;
-                                        } else {
-                                            if was_active {
-                                                self.config.active_endpoint = self.config.endpoints[0].url.clone();
-                                                self.menu = None;
-                                                self.breadcrumbs.clear();
-                                                self.selected_index = 0;
-                                                self.menu_scroll_offset = 0;
-                                                self.load_menu().await;
-                                            }
-                                            let new_sel = ret.min(self.config.endpoints.len() - 1);
-                                            self.popup = Some(Popup::EndpointSelector {
-                                                selected: new_sel,
-                                                scroll_offset: 0,
-                                            });
-                                        }
-                                    }
-                                }
-                                KeyCode::Char('n') | KeyCode::Char('N') | KeyCode::Esc => {
-                                    let ret = *return_selected;
-                                    self.popup = Some(Popup::EndpointSelector {
-                                        selected: ret,
-                                        scroll_offset: 0,
-                                    });
-                                }
                                 _ => {}
                             }
                             return Ok(false);
@@ -793,21 +500,34 @@ impl App {
                                     let tx = self.event_tx.clone();
                                     let info_clone = info.clone();
 
+                                    // Forward progress events
                                     tokio::spawn(async move {
                                         while let Some(bytes) = progress_rx.recv().await {
                                             let _ = tx.send(Event::UpdateProgress(bytes));
                                         }
                                     });
 
+                                    // Download and apply
                                     let tx2 = self.event_tx.clone();
                                     tokio::spawn(async move {
-                                        match updater::download_and_apply(&info_clone, progress_tx).await {
+                                        match updater::download_and_apply(
+                                            &info_clone,
+                                            progress_tx,
+                                        )
+                                        .await
+                                        {
                                             Ok(exe_path) => {
-                                                updater::write_update_target(&info_clone.new_version);
+                                                // Write expected version before exec so
+                                                // the next startup can detect a failed
+                                                // replacement (wrong asset, etc.).
+                                                updater::write_update_target(
+                                                    &info_clone.new_version,
+                                                );
                                                 let _ = tx2.send(Event::UpdateDone(exe_path));
                                             }
                                             Err(e) => {
-                                                let _ = tx2.send(Event::UpdateError(e.to_string()));
+                                                let _ =
+                                                    tx2.send(Event::UpdateError(e.to_string()));
                                             }
                                         }
                                     });
@@ -826,6 +546,7 @@ impl App {
                                 if matches!(status, UpdatingStatus::Failed(_)) {
                                     self.popup = None;
                                 }
+                                // Ignore Esc while downloading/applying
                             }
                             return Ok(false);
                         }
@@ -834,80 +555,35 @@ impl App {
                     }
                 }
 
-                // ── Main menu navigation ──────────────────────────────────────────
+                // ── Main menu navigation ─────────────────────────────────────────
                 match key.code {
                     KeyCode::Char('q') => return Ok(true),
                     KeyCode::Up | KeyCode::Char('k') => {
                         let len = self.current_items().len();
                         if len > 0 {
-                            self.selected_index = self.selected_index.saturating_sub(1);
+                            self.selected_index = (self.selected_index + len - 1) % len;
                         }
                     }
                     KeyCode::Down | KeyCode::Char('j') => {
                         let len = self.current_items().len();
-                        if len > 0 && self.selected_index + 1 < len {
+                        if len > 0 {
-                            self.selected_index += 1;
+                            self.selected_index = (self.selected_index + 1) % len;
                         }
                     }
-                    KeyCode::Enter | KeyCode::Char('l') | KeyCode::Right => {
+                    KeyCode::Enter | KeyCode::Char('l') => {
                         if let Some(item) = self.selected_item().cloned() {
                             self.activate_item(item).await?;
                         }
                     }
-                    KeyCode::Esc | KeyCode::Char('h') | KeyCode::Left => {
+                    KeyCode::Esc | KeyCode::Char('h') => {
                         if !self.breadcrumbs.is_empty() {
                             self.breadcrumbs.pop();
                             self.selected_index = 0;
-                            self.menu_scroll_offset = 0;
                         }
                     }
                     KeyCode::Char('r') | KeyCode::Char('R') => {
                         self.load_menu().await;
                     }
-                    KeyCode::Tab => {
-                        let sel = self.config.endpoints.iter()
-                            .position(|ep| ep.url == self.config.active_endpoint)
-                            .unwrap_or(0);
-                        self.popup = Some(Popup::EndpointSelector {
-                            selected: sel,
-                            scroll_offset: 0,
-                        });
-                    }
-                    _ => {}
-                }
-            }
-            CrosstermEvent::Mouse(mouse) => {
-                use crossterm::event::MouseEventKind;
-                match mouse.kind {
-                    MouseEventKind::ScrollUp => {
-                        if let Some(Popup::ExecutingStructured { log_scroll_pos, log_follow_bottom, .. }) = &mut self.popup {
-                            *log_scroll_pos = log_scroll_pos.saturating_sub(3);
-                            *log_follow_bottom = false;
-                        } else if let Some(Popup::EndpointSelector { selected, .. }) = &mut self.popup {
-                            if *selected > 0 { *selected -= 1; }
-                        } else if self.popup.is_none() {
-                            let len = self.current_items().len();
-                            if len > 0 {
-                                self.selected_index = (self.selected_index + len - 1) % len;
-                            }
-                        }
-                    }
-                    MouseEventKind::ScrollDown => {
-                        if let Some(Popup::ExecutingStructured {
-                            log_scroll_pos, log_follow_bottom, log_buffer, ..
-                        }) = &mut self.popup {
-                            *log_scroll_pos = log_scroll_pos.saturating_add(3);
-                            *log_follow_bottom = *log_scroll_pos + 1 >= log_buffer.len();
-                        } else if let Some(Popup::EndpointSelector { selected, .. }) = &mut self.popup {
-                            let len = self.config.endpoints.len();
-                            if *selected + 1 < len { *selected += 1; }
-                        } else if self.popup.is_none() {
-                            let len = self.current_items().len();
-                            if len > 0 {
-                                self.selected_index = (self.selected_index + 1) % len;
-                            }
-                        }
-                    }
                     _ => {}
                 }
             }
@@ -942,11 +618,24 @@ impl App {
 
     async fn run_action(&mut self, action: Action) -> Result<()> {
         match action {
-            Action::Bash { script, interaction, confirm: _, confirm_message: _ } => match interaction {
+            Action::Bash {
-                InteractionMode::Terminal => self.run_bash_terminal(&script).await?,
+                script,
-                InteractionMode::Structured => self.run_bash_structured(&script).await?,
+                interaction,
+                confirm: _,
+                confirm_message: _,
+            } => match interaction {
+                InteractionMode::Terminal => {
+                    self.run_bash_terminal(&script).await?;
+                }
+                InteractionMode::Structured => {
+                    self.run_bash_structured(&script).await?;
+                }
             },
-            Action::Download { url, confirm: _, .. } => {
+            Action::Download {
+                url,
+                confirm: _,
+                ..
+            } => {
                 self.popup = Some(Popup::Message {
                     text: format!("Скачивание {} пока не реализовано", url),
                     level: MessageLevel::Info,
@@ -973,7 +662,9 @@ impl App {
         tokio::spawn(async move {
             let mut rx = output_rx;
             while let Some(line) = rx.recv().await {
-                if tx_output.send(Event::StructuredOutput(line)).is_err() { break; }
+                if tx_output.send(Event::StructuredOutput(line)).is_err() {
+                    break;
+                }
             }
         });
 
@@ -981,7 +672,9 @@ impl App {
         tokio::spawn(async move {
             let mut rx = command_rx;
             while let Some(cmd) = rx.recv().await {
-                if tx_cmd.send(Event::StructuredCommand(cmd)).is_err() { break; }
+                if tx_cmd.send(Event::StructuredCommand(cmd)).is_err() {
+                    break;
+                }
             }
         });
 
@@ -996,12 +689,9 @@ impl App {
             kill_tx: Some(kill_tx),
             log_buffer: Vec::new(),
             current_command: None,
-            input: TextInput::new(),
+            input_buffer: String::new(),
             menu_selected_index: 0,
-            form_cursor: 0,
-            form_values: Vec::new(),
             log_scroll_pos: 0,
-            log_scroll_x: 0,
             log_follow_bottom: false,
             finished: None,
         });

src/config.rs

@@ -3,21 +3,9 @@ use anyhow::Result;
 use std::fs;
 use std::path::PathBuf;
 
-#[derive(Debug, Deserialize, Serialize, Clone)]
-pub struct Endpoint {
-    pub name: String,
-    pub url: String,
-}
-
 #[derive(Debug, Deserialize, Serialize, Clone)]
 pub struct Config {
-    // Legacy field — present only in old configs; migrated to endpoints on load.
+    pub server_url: String,
-    #[serde(default, skip_serializing)]
-    server_url: Option<String>,
-    #[serde(default)]
-    pub endpoints: Vec<Endpoint>,
-    #[serde(default)]
-    pub active_endpoint: String,
     pub timeout_sec: u64,
     #[serde(default = "default_theme")]
     pub theme: Theme,
@@ -42,6 +30,7 @@ fn default_theme() -> Theme {
 }
 
 pub fn config_path() -> PathBuf {
+    // Respect XDG_CONFIG_HOME; fall back to ~/.config on all platforms.
     let base = std::env::var("XDG_CONFIG_HOME")
         .map(PathBuf::from)
         .unwrap_or_else(|_| {
@@ -53,85 +42,41 @@ pub fn config_path() -> PathBuf {
 }
 
 impl Config {
+    /// Returns true when a config file already exists.
     pub fn exists() -> bool {
         config_path().exists()
     }
 
-    pub fn active_url(&self) -> &str {
+    /// Load config from disk. Panics-safe: returns error if file is missing or malformed.
-        &self.active_endpoint
-    }
-
     pub fn load() -> Result<Self> {
         let path = config_path();
         let content = fs::read_to_string(&path)?;
-        let mut cfg: Config = toml::from_str(&content)?;
+        Ok(toml::from_str(&content)?)
-        // Migrate old single server_url format to endpoints list.
-        if cfg.endpoints.is_empty() {
-            if let Some(url) = cfg.server_url.take() {
-                cfg.active_endpoint = url.clone();
-                cfg.endpoints.push(Endpoint {
-                    name: "Default".to_string(),
-                    url,
-                });
-            }
-        }
-        if cfg.active_endpoint.is_empty() {
-            if let Some(ep) = cfg.endpoints.first() {
-                cfg.active_endpoint = ep.url.clone();
-            }
-        }
-        Ok(cfg)
     }
 
-    pub fn create_with_endpoint(url: &str, name: &str) -> Result<Self> {
+    /// Create and persist a new config with the given server URL.
+    pub fn create_with_url(server_url: &str) -> Result<Self> {
         let path = config_path();
         let config = Config {
-            server_url: None,
+            server_url: server_url.to_string(),
-            endpoints: vec![Endpoint {
-                name: name.to_string(),
-                url: url.to_string(),
-            }],
-            active_endpoint: url.to_string(),
             timeout_sec: 10,
             theme: default_theme(),
             update_api: Some("https://git.vainend.com/api/v1/repos/admin/ostiary".to_string()),
         };
+        let contents = format!(
+            r#"server_url = "{}"
+timeout_sec = {}
+update_api = "https://git.vainend.com/api/v1/repos/admin/ostiary"
+
+[theme]
+selected_bg = "{}"
+"#,
+            config.server_url,
+            config.timeout_sec,
+            config.theme.selected_bg,
+        );
         fs::create_dir_all(path.parent().unwrap())?;
-        fs::write(&path, config.to_toml())?;
+        fs::write(&path, contents)?;
         Ok(config)
     }
-
-    pub fn save(&self) -> Result<()> {
-        let path = config_path();
-        fs::create_dir_all(path.parent().unwrap())?;
-        fs::write(&path, self.to_toml())?;
-        Ok(())
-    }
-
-    fn to_toml(&self) -> String {
-        let mut s = format!(
-            "active_endpoint = \"{}\"\ntimeout_sec = {}\n",
-            escape_toml(&self.active_endpoint),
-            self.timeout_sec,
-        );
-        if let Some(api) = &self.update_api {
-            s.push_str(&format!("update_api = \"{}\"\n", escape_toml(api)));
-        }
-        s.push_str(&format!(
-            "\n[theme]\nselected_bg = \"{}\"\n",
-            escape_toml(&self.theme.selected_bg),
-        ));
-        for ep in &self.endpoints {
-            s.push_str(&format!(
-                "\n[[endpoints]]\nname = \"{}\"\nurl = \"{}\"\n",
-                escape_toml(&ep.name),
-                escape_toml(&ep.url),
-            ));
-        }
-        s
-    }
-}
-
-fn escape_toml(s: &str) -> String {
-    s.replace('\\', "\\\\").replace('"', "\\\"")
 }

src/executor/mod.rs

@@ -1,4 +1,4 @@
 pub mod structured;
-pub use structured::{StructuredCommand, MessageLevel, FormFieldType};
+pub use structured::{StructuredCommand, MessageLevel};
 
 // Здесь могут быть функции для download, http и т.д.

src/executor/structured.rs

@@ -28,39 +28,18 @@ pub enum StructuredCommand {
         text: String,
     },
     Progress {
-        /// Some(n) = deterministic bar (0-100).
+        percent: u8,
-        /// None    = indeterminate spinner (percent omitted from JSON).
-        percent: Option<u8>,
         message: Option<String>,
     },
-    /// A list of checkboxes and radio buttons.
-    /// Response: space-separated IDs of all checked/selected fields.
-    Form {
-        prompt: String,
-        fields: Vec<FormField>,
-    },
     /// Run an interactive program that needs the real terminal.
+    /// The client suspends ratatui, inherits stdin/stdout/stderr, waits for
+    /// the process to exit, then restores the TUI.
+    /// The script receives the exit code as the response.
     Exec {
         shell: String,
     },
 }
 
-#[derive(Debug, Clone, PartialEq)]
-pub enum FormFieldType {
-    Checkbox,
-    Radio,
-}
-
-#[derive(Debug, Clone)]
-pub struct FormField {
-    pub id: String,
-    pub label: String,
-    pub field_type: FormFieldType,
-    pub default: bool,
-    /// Radio buttons with the same group are mutually exclusive.
-    pub group: Option<String>,
-}
-
 #[derive(Debug)]
 pub struct MenuOption {
     pub id: String,
@@ -220,30 +199,10 @@ fn parse_command(json_str: &str, cmd_tx: UnboundedSender<StructuredCommand>) ->
             StructuredCommand::Message { level, text }
         }
         "progress" => {
-            // percent absent or null → None (indeterminate spinner)
+            let percent = v["percent"].as_u64().unwrap_or(0) as u8;
-            let percent = v["percent"].as_u64().map(|n| n.min(100) as u8);
             let message = v["message"].as_str().map(String::from);
             StructuredCommand::Progress { percent, message }
         }
-        "form" => {
-            let prompt = v["prompt"].as_str().unwrap_or("").to_string();
-            let fields = v["fields"].as_array()
-                .map(|arr| {
-                    arr.iter().filter_map(|f| {
-                        let id = f["id"].as_str()?.to_string();
-                        let label = f["label"].as_str()?.to_string();
-                        let field_type = match f["field_type"].as_str().unwrap_or("checkbox") {
-                            "radio" => FormFieldType::Radio,
-                            _ => FormFieldType::Checkbox,
-                        };
-                        let default = f["default"].as_bool().unwrap_or(false);
-                        let group = f["group"].as_str().map(String::from);
-                        Some(FormField { id, label, field_type, default, group })
-                    }).collect()
-                })
-                .unwrap_or_default();
-            StructuredCommand::Form { prompt, fields }
-        }
         "exec" => {
             let shell = v["shell"].as_str().unwrap_or("").to_string();
             StructuredCommand::Exec { shell }

src/main.rs

@@ -5,7 +5,6 @@ mod error;
 mod executor;
 mod menu;
 mod network;
-mod text_input;
 mod ui;
 mod updater;
 
@@ -24,8 +23,8 @@ async fn main() -> Result<()> {
     let config = if config::Config::exists() {
         config::Config::load()?
     } else {
-        let (url, name) = prompt_first_endpoint()?;
+        let url = prompt_server_url()?;
-        config::Config::create_with_endpoint(&url, &name)?
+        config::Config::create_with_url(&url)?
     };
 
     enable_raw_mode()?;
@@ -108,7 +107,7 @@ async fn run_app(
             terminal.show_cursor()?;
             #[cfg(unix)]
             updater::exec_updated(&exe_path);
-            #[cfg(not(unix))]
+            // fallback for non-unix or if exec failed
             break;
         }
 
@@ -167,8 +166,8 @@ async fn run_exec(
     Ok(())
 }
 
-/// Runs before ratatui starts. Prompts for endpoint URL and name on first launch.
+/// Runs before ratatui starts. Prompts for the server URL on first launch.
-fn prompt_first_endpoint() -> Result<(String, String)> {
+fn prompt_server_url() -> Result<String> {
     use std::io::Write;
 
     println!();
@@ -180,34 +179,22 @@ fn prompt_first_endpoint() -> Result<(String, String)> {
     println!("  {}", config::config_path().display());
     println!();
 
-    let name = loop {
+    loop {
-        print!("  Название эндпоинта: ");
+        print!("  URL сервера меню: ");
         std::io::stdout().flush()?;
-        let mut buf = String::new();
-        std::io::stdin().read_line(&mut buf)?;
-        let val = buf.trim().to_string();
-        if val.is_empty() {
-            println!("  Название не может быть пустым. Попробуйте ещё раз.\n");
-            continue;
-        }
-        break val;
-    };
 
-    let url = loop {
+        let mut url = String::new();
-        print!("  URL эндпоинта: ");
+        std::io::stdin().read_line(&mut url)?;
-        std::io::stdout().flush()?;
+        let url = url.trim().to_string();
-        let mut buf = String::new();
+
-        std::io::stdin().read_line(&mut buf)?;
+        if url.is_empty() {
-        let val = buf.trim().to_string();
-        if val.is_empty() {
             println!("  URL не может быть пустым. Попробуйте ещё раз.\n");
             continue;
         }
-        break val;
-    };
 
-    println!();
+        println!();
-    Ok((url, name))
+        return Ok(url);
+    }
 }
 
 async fn read_crossterm_event() -> Result<Option<crossterm::event::Event>> {

src/text_input.rs

@@ -1,98 +0,0 @@
-use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
-
-pub struct TextInput {
-    pub buf: String,
-    pub cursor: usize,
-}
-
-impl TextInput {
-    pub fn new() -> Self {
-        Self { buf: String::new(), cursor: 0 }
-    }
-
-    pub fn with_text(text: impl Into<String>) -> Self {
-        let buf = text.into();
-        let cursor = buf.chars().count();
-        Self { buf, cursor }
-    }
-
-    pub fn value(&self) -> &str {
-        &self.buf
-    }
-
-    pub fn clear(&mut self) {
-        self.buf.clear();
-        self.cursor = 0;
-    }
-
-    pub fn move_left(&mut self) {
-        self.cursor = self.cursor.saturating_sub(1);
-    }
-
-    pub fn move_right(&mut self) {
-        self.cursor = (self.cursor + 1).min(self.buf.chars().count());
-    }
-
-    pub fn word_back(&mut self) {
-        let chars: Vec<char> = self.buf.chars().collect();
-        let mut pos = self.cursor;
-        while pos > 0 && !is_word(chars[pos - 1]) { pos -= 1; }
-        while pos > 0 && is_word(chars[pos - 1]) { pos -= 1; }
-        self.cursor = pos;
-    }
-
-    pub fn word_fwd(&mut self) {
-        let chars: Vec<char> = self.buf.chars().collect();
-        let len = chars.len();
-        let mut pos = self.cursor;
-        while pos < len && !is_word(chars[pos]) { pos += 1; }
-        while pos < len && is_word(chars[pos]) { pos += 1; }
-        self.cursor = pos;
-    }
-
-    pub fn insert(&mut self, c: char) {
-        let byte_idx = self.buf.char_indices().nth(self.cursor).map(|(b, _)| b).unwrap_or(self.buf.len());
-        self.buf.insert(byte_idx, c);
-        self.cursor += 1;
-    }
-
-    pub fn backspace(&mut self) {
-        if self.cursor == 0 { return; }
-        let byte_idx = self.buf.char_indices().nth(self.cursor - 1).map(|(b, _)| b).unwrap_or(0);
-        self.buf.remove(byte_idx);
-        self.cursor -= 1;
-    }
-
-    pub fn word_delete_back(&mut self) {
-        let chars: Vec<char> = self.buf.chars().collect();
-        let mut new_cursor = self.cursor;
-        while new_cursor > 0 && !is_word(chars[new_cursor - 1]) { new_cursor -= 1; }
-        while new_cursor > 0 && is_word(chars[new_cursor - 1]) { new_cursor -= 1; }
-        if new_cursor == self.cursor { return; }
-        let start_byte = self.buf.char_indices().nth(new_cursor).map(|(b, _)| b).unwrap_or(0);
-        let end_byte = self.buf.char_indices().nth(self.cursor).map(|(b, _)| b).unwrap_or(self.buf.len());
-        self.buf.drain(start_byte..end_byte);
-        self.cursor = new_cursor;
-    }
-
-    /// Returns true if the key was consumed.
-    pub fn handle_key(&mut self, key: &KeyEvent) -> bool {
-        let alt = key.modifiers.intersects(KeyModifiers::ALT | KeyModifiers::SUPER);
-        match key.code {
-            KeyCode::Left if alt => { self.word_back(); true }
-            KeyCode::Right if alt => { self.word_fwd(); true }
-            KeyCode::Char('b') if alt => { self.word_back(); true }
-            KeyCode::Char('f') if alt => { self.word_fwd(); true }
-            KeyCode::Left => { self.move_left(); true }
-            KeyCode::Right => { self.move_right(); true }
-            KeyCode::Backspace if alt => { self.word_delete_back(); true }
-            KeyCode::Backspace => { self.backspace(); true }
-            KeyCode::Char(c) => { self.insert(c); true }
-            _ => false,
-        }
-    }
-}
-
-fn is_word(c: char) -> bool {
-    c.is_alphanumeric() || c == '_'
-}

src/ui.rs

@@ -1,8 +1,6 @@
 use crate::ansi;
-use crate::config::Config;
 use crate::executor;
 use crate::app::{App, MessageLevel, Popup, UpdatingStatus};
-use crate::text_input::TextInput;
 use ratatui::{
     layout::{Alignment, Constraint, Direction, Layout, Rect},
     style::{Color, Modifier, Style},
@@ -26,115 +24,44 @@ pub fn render(f: &mut Frame, app: &mut App) {
     render_description(f, app, chunks[1]);
 
     if let Some(popup) = &mut app.popup {
-        render_popup(f, popup, &app.config);
+        render_popup(f, popup);
     }
 }
 
-fn render_menu(f: &mut Frame, app: &mut App, area: Rect) {
+fn render_menu(f: &mut Frame, app: &App, area: Rect) {
-    const SCROLLOFF: usize = 1;
-
     let items = app.current_items();
-    let total = items.len();
+    let list_items: Vec<ListItem> = items
-    let inner_w = area.width.saturating_sub(2) as usize;
-    let inner_h = area.height.saturating_sub(2) as usize;
-    let sel = if total > 0 { app.selected_index.min(total - 1) } else { 0 };
-
-    let item_lines: Vec<Vec<String>> = items.iter().map(|item| {
-        let prefix = match &item.kind {
-            crate::menu::MenuItemKind::Category { .. } => "📁 ",
-            crate::menu::MenuItemKind::Action { .. } => "⚡ ",
-        };
-        wrap_to_lines(&format!("{}{}", prefix, item.title), inner_w)
-    }).collect();
-
-    let vis_from = |off: usize| -> usize {
-        let mut rows = 0usize;
-        let mut n = 0usize;
-        for lines in item_lines.get(off..).unwrap_or(&[]) {
-            let h = lines.len().max(1);
-            if rows + h > inner_h { break; }
-            rows += h;
-            n += 1;
-        }
-        n
-    };
-
-    let offset = &mut app.menu_scroll_offset;
-    if total == 0 {
-        *offset = 0;
-    } else {
-        if *offset > sel { *offset = sel; }
-        if sel < offset.saturating_add(SCROLLOFF) && *offset > 0 {
-            *offset = sel.saturating_sub(SCROLLOFF);
-        }
-        loop {
-            let vis = vis_from(*offset);
-            if vis == 0 { break; }
-            let trigger = offset.saturating_add(vis).saturating_sub(SCROLLOFF);
-            if sel >= trigger && *offset + vis < total {
-                *offset += 1;
-            } else {
-                break;
-            }
-        }
-        let max_off = total.saturating_sub(1);
-        *offset = (*offset).min(max_off);
-    }
-
-    let start = *offset;
-    let vis = vis_from(start);
-    let end = (start + vis).min(total);
-
-    let list_items: Vec<ListItem> = item_lines[start..end]
         .iter()
         .enumerate()
-        .map(|(i, lines)| {
+        .map(|(i, item)| {
-            let abs = start + i;
+            let prefix = match &item.kind {
-            let text: Vec<Line> = lines.iter().map(|l| Line::from(l.clone())).collect();
+                crate::menu::MenuItemKind::Category { .. } => "📁 ",
-            let li = ListItem::new(ratatui::text::Text::from(text));
+                crate::menu::MenuItemKind::Action { .. } => "⚡ ",
-            if abs == sel {
+            };
-                li.style(Style::default().bg(Color::Blue).add_modifier(Modifier::BOLD))
+            let content = Line::from(Span::raw(format!("{}{}", prefix, item.title)));
+            if i == app.selected_index {
+                ListItem::new(content).style(Style::default().bg(Color::Blue))
             } else {
-                li
+                ListItem::new(content)
             }
         })
         .collect();
 
-    let endpoint_title = app.config.endpoints.iter()
+    let list = List::new(list_items)
-        .find(|ep| ep.url == app.config.active_endpoint)
+        .block(
-        .map(|ep| format!(" {} ", ep.name))
+            Block::default()
-        .unwrap_or_else(|| " Меню ".to_string());
+                .borders(Borders::ALL)
-
+                .title(" Меню ")
-    let list = List::new(list_items).block(
+                .title(
-        Block::default()
+                    Line::from(Span::styled(
-            .borders(Borders::ALL)
+                        format!(" v{} ", env!("CARGO_PKG_VERSION")),
-            .title(endpoint_title)
+                        Style::default().fg(Color::DarkGray),
-            .title(
+                    ))
-                Line::from(Span::styled(
+                    .alignment(Alignment::Right),
-                    format!(" v{} ", env!("CARGO_PKG_VERSION")),
+                ),
-                    Style::default().fg(Color::DarkGray),
+        )
-                ))
+        .highlight_style(Style::default().add_modifier(Modifier::BOLD));
-                .alignment(Alignment::Right),
-            ),
-    );
     f.render_widget(list, area);
-
-    if total > vis {
-        let max_off = total.saturating_sub(vis);
-        let scrollbar = Scrollbar::default()
-            .orientation(ScrollbarOrientation::VerticalRight)
-            .begin_symbol(Some("▲"))
-            .end_symbol(Some("▼"))
-            .thumb_symbol("█");
-        let mut sb_state = ScrollbarState::new(max_off).position(start);
-        let sb_area = Rect {
-            x: area.x + area.width.saturating_sub(1),
-            y: area.y + 1,
-            width: 1,
-            height: area.height.saturating_sub(2),
-        };
-        f.render_stateful_widget(scrollbar, sb_area, &mut sb_state);
-    }
 }
 
 fn render_description(f: &mut Frame, app: &App, area: Rect) {
@@ -151,9 +78,10 @@ fn render_description(f: &mut Frame, app: &App, area: Rect) {
     f.render_widget(paragraph, area);
 }
 
-fn render_popup(f: &mut Frame, popup: &mut Popup, config: &Config) {
+fn render_popup(f: &mut Frame, popup: &mut Popup) {
     let area = f.area();
 
+    // Use a smaller area for update-related popups
     let popup_area = match popup {
         Popup::UpdateConfirm { .. } | Popup::Updating { .. } => centered_rect(50, 40, area),
         _ => centered_rect(80, 90, area),
@@ -162,7 +90,11 @@ fn render_popup(f: &mut Frame, popup: &mut Popup, config: &Config) {
     f.render_widget(Clear, popup_area);
 
     match popup {
-        Popup::Confirming { action: _, item_title, confirm_message } => {
+        Popup::Confirming {
+            action: _,
+            item_title,
+            confirm_message,
+        } => {
             let block = Block::default()
                 .borders(Borders::ALL)
                 .title("Подтверждение")
@@ -186,10 +118,11 @@ fn render_popup(f: &mut Frame, popup: &mut Popup, config: &Config) {
                     )),
                 ]
             };
-            f.render_widget(
+            let paragraph = Paragraph::new(text)
-                Paragraph::new(text).block(block).alignment(Alignment::Center).wrap(Wrap { trim: true }),
+                .block(block)
-                popup_area,
+                .alignment(Alignment::Center)
-            );
+                .wrap(Wrap { trim: true });
+            f.render_widget(paragraph, popup_area);
         }
 
         Popup::ExecutingStructured {
@@ -197,18 +130,16 @@ fn render_popup(f: &mut Frame, popup: &mut Popup, config: &Config) {
             kill_tx: _,
             log_buffer,
             current_command,
-            input,
+            input_buffer,
             menu_selected_index,
-            form_cursor,
-            form_values,
             log_scroll_pos,
-            log_scroll_x,
             log_follow_bottom,
             finished,
         } => {
             let cmd_height: u16 = match current_command {
-                Some(executor::StructuredCommand::Menu { options, .. }) => (options.len() as u16 + 2).min(14),
+                Some(executor::StructuredCommand::Menu { options, .. }) => {
-                Some(executor::StructuredCommand::Form { fields, .. }) => (fields.len() as u16 + 2).min(16),
+                    (options.len() as u16 + 2).min(14)
+                }
                 Some(_) => 5,
                 None => 0,
             };
@@ -219,9 +150,11 @@ fn render_popup(f: &mut Frame, popup: &mut Popup, config: &Config) {
                 .constraints([Constraint::Min(3), Constraint::Length(cmd_height)].as_ref())
                 .split(popup_area);
 
+            // ── Scrollable log ──────────────────────────────────────────────
             let visible = chunks[0].height.saturating_sub(2) as usize;
             let total = log_buffer.len();
 
+            // Clamp pos so we never show empty lines past the end.
             let max_pos = total.saturating_sub(visible);
             if *log_follow_bottom {
                 *log_scroll_pos = max_pos;
@@ -232,20 +165,13 @@ fn render_popup(f: &mut Frame, popup: &mut Popup, config: &Config) {
             let start = pos;
             let end = (start + visible).min(total);
 
-            let viewport_w = chunks[0].width.saturating_sub(2) as usize;
-            let max_content_w: usize = log_buffer
-                .iter()
-                .map(|l| ansi::parse_line(l).iter().map(|(_, s)| s.chars().count()).sum::<usize>())
-                .max()
-                .unwrap_or(0);
-            let max_scroll_x = max_content_w.saturating_sub(viewport_w);
-            *log_scroll_x = (*log_scroll_x).min(max_scroll_x);
-            let scroll_x = *log_scroll_x;
-
             let log_items: Vec<ListItem> = log_buffer[start..end]
                 .iter()
                 .map(|line| {
-                    let spans: Vec<Span> = h_scroll(ansi::parse_line(line), scroll_x);
+                    let spans: Vec<Span> = ansi::parse_line(line)
+                        .into_iter()
+                        .map(|(style, text)| Span::styled(text, style))
+                        .collect();
                     ListItem::new(Line::from(spans))
                 })
                 .collect();
@@ -253,32 +179,37 @@ fn render_popup(f: &mut Frame, popup: &mut Popup, config: &Config) {
             let at_bottom = pos >= max_pos;
             let at_top = pos == 0;
 
-            let scroll_hint = if total <= visible {
-                String::new()
-            } else if at_top && at_bottom {
-                String::new()
-            } else if at_top {
-                format!(" │ PgDn/↓ вниз ({}/{})", end, total)
-            } else if at_bottom {
-                format!(" │ PgUp/↑ вверх ({}/{})", end, total)
-            } else {
-                format!(" │ PgUp ↑  PgDn ↓ ({}/{})", end, total)
-            };
-
             let (title, border_color): (String, Color) = match finished {
-                Some(0) => (format!(" ✓ Завершено — Esc закрыть{} ", scroll_hint), Color::Green),
+                Some(0) => (
-                Some(code) => (format!(" ✗ Ошибка (код {}) — Esc закрыть{} ", code, scroll_hint), Color::Red),
+                    " ✓ Завершено — Esc закрыть │ PgUp/↑↓ скролл ".to_string(),
-                None if at_top && at_bottom => (" Выполняется… ".to_string(), Color::DarkGray),
+                    Color::Green,
-                None if at_bottom => (" Выполняется… │ PgUp/↑ прокрутить вверх ".to_string(), Color::DarkGray),
+                ),
-                None => (format!(" Выполняется… │ {}/{} │ PgDn/↓ вниз ", pos + 1, total), Color::Yellow),
+                Some(code) => (
+                    format!(" ✗ Ошибка (код {}) — Esc закрыть │ PgUp/↑↓ скролл ", code),
+                    Color::Red,
+                ),
+                None if at_top && at_bottom => (
+                    " Выполняется… ".to_string(),
+                    Color::DarkGray,
+                ),
+                None if at_bottom => (
+                    " Выполняется… │ PgUp/↑ прокрутить вверх ".to_string(),
+                    Color::DarkGray,
+                ),
+                None => (
+                    format!(" Выполняется… │ {}/{} │ PgDn/↓ вниз ", pos + 1, total),
+                    Color::Yellow,
+                ),
             };
 
             let log_block = Block::default()
                 .borders(Borders::ALL)
                 .title(title.as_str())
                 .border_style(Style::default().fg(border_color));
+
             f.render_widget(List::new(log_items).block(log_block), chunks[0]);
 
+            // ── Scrollbar ───────────────────────────────────────────────────
             if total > visible {
                 let scrollbar = Scrollbar::default()
                     .orientation(ScrollbarOrientation::VerticalRight)
@@ -295,28 +226,10 @@ fn render_popup(f: &mut Frame, popup: &mut Popup, config: &Config) {
                 f.render_stateful_widget(scrollbar, sb_area, &mut sb_state);
             }
 
-            if max_content_w > viewport_w {
+            // ── Interactive command area ─────────────────────────────────────
-                let mut h_state = ScrollbarState::new(max_scroll_x).position(scroll_x);
-                let hscroll_area = Rect {
-                    x: chunks[0].x + 1,
-                    y: chunks[0].y + chunks[0].height.saturating_sub(1),
-                    width: chunks[0].width.saturating_sub(2),
-                    height: 1,
-                };
-                f.render_stateful_widget(
-                    Scrollbar::new(ScrollbarOrientation::HorizontalBottom)
-                        .begin_symbol(Some("◄"))
-                        .end_symbol(Some("►"))
-                        .thumb_symbol("▄")
-                        .track_symbol(Some("─")),
-                    hscroll_area,
-                    &mut h_state,
-                );
-            }
-
             if cmd_height > 0 {
                 if let Some(cmd) = current_command {
-                    render_command(f, cmd, input, *menu_selected_index, *form_cursor, form_values, chunks[1]);
+                    render_command(f, cmd, input_buffer, *menu_selected_index, chunks[1]);
                 }
             }
         }
@@ -331,16 +244,20 @@ fn render_popup(f: &mut Frame, popup: &mut Popup, config: &Config) {
                 .borders(Borders::ALL)
                 .title("Сообщение")
                 .border_style(Style::default().fg(color));
-            f.render_widget(
+            let paragraph = Paragraph::new(text.as_str())
-                Paragraph::new(text.as_str()).block(block).alignment(Alignment::Center).wrap(Wrap { trim: true }),
+                .block(block)
-                popup_area,
+                .alignment(Alignment::Center)
-            );
+                .wrap(Wrap { trim: true });
+            f.render_widget(paragraph, popup_area);
         }
 
         Popup::UpdateConfirm { info } => {
             let mut lines = vec![
                 Line::from(""),
-                Line::from(Span::raw(format!("  {} → {}", info.current_version, info.new_version))),
+                Line::from(Span::raw(format!(
+                    "  {} → {}",
+                    info.current_version, info.new_version
+                ))),
             ];
             if info.size > 0 {
                 let mb = info.size as f64 / 1_048_576.0;
@@ -356,10 +273,17 @@ fn render_popup(f: &mut Frame, popup: &mut Popup, config: &Config) {
                 .borders(Borders::ALL)
                 .title(" Доступно обновление ")
                 .border_style(Style::default().fg(Color::Cyan));
-            f.render_widget(Paragraph::new(lines).block(block).wrap(Wrap { trim: true }), popup_area);
+            let paragraph = Paragraph::new(lines)
+                .block(block)
+                .wrap(Wrap { trim: true });
+            f.render_widget(paragraph, popup_area);
         }
 
-        Popup::Updating { info, downloaded, status } => {
+        Popup::Updating {
+            info,
+            downloaded,
+            status,
+        } => {
             let (title, border_color) = match status {
                 UpdatingStatus::Downloading => (" Загрузка обновления… ", Color::Cyan),
                 UpdatingStatus::Applying => (" Применение обновления… ", Color::Yellow),
@@ -370,14 +294,23 @@ fn render_popup(f: &mut Frame, popup: &mut Popup, config: &Config) {
             let bar_width = popup_area.width.saturating_sub(4) as usize;
 
             let progress_line = if info.size > 0 {
-                let percent = ((*downloaded as f64 / info.size as f64) * 100.0).min(100.0) as usize;
+                let percent = ((*downloaded as f64 / info.size as f64) * 100.0)
+                    .min(100.0) as usize;
                 let filled = (percent * bar_width) / 100;
-                format!("[{}{}] {}%", "█".repeat(filled), "░".repeat(bar_width.saturating_sub(filled)), percent)
+                format!(
+                    "[{}{}] {}%",
+                    "█".repeat(filled),
+                    "░".repeat(bar_width.saturating_sub(filled)),
+                    percent
+                )
             } else {
+                // Indeterminate: animate based on downloaded bytes
                 let pos = ((*downloaded / 4096) as usize) % bar_width.max(1);
                 let thumb = 4.min(bar_width);
                 let mut bar = vec!['░'; bar_width];
-                for i in pos..((pos + thumb).min(bar_width)) { bar[i] = '█'; }
+                for i in pos..((pos + thumb).min(bar_width)) {
+                    bar[i] = '█';
+                }
                 format!("[{}]", bar.iter().collect::<String>())
             };
 
@@ -388,7 +321,8 @@ fn render_popup(f: &mut Frame, popup: &mut Popup, config: &Config) {
                         let mb_total = info.size as f64 / 1_048_576.0;
                         format!("  {:.1} / {:.1} МБ", mb_done, mb_total)
                     } else {
-                        format!("  {} КБ загружено", *downloaded / 1024)
+                        let kb = *downloaded / 1024;
+                        format!("  {} КБ загружено", kb)
                     }
                 }
                 UpdatingStatus::Applying => "  Применяется…".to_string(),
@@ -405,229 +339,49 @@ fn render_popup(f: &mut Frame, popup: &mut Popup, config: &Config) {
 
             if matches!(status, UpdatingStatus::Failed(_)) {
                 lines.push(Line::from(""));
-                lines.push(Line::from(Span::styled("  [Esc] Закрыть", Style::default().fg(Color::Yellow))));
+                lines.push(Line::from(Span::styled(
+                    "  [Esc] Закрыть",
+                    Style::default().fg(Color::Yellow),
+                )));
             }
 
             let block = Block::default()
                 .borders(Borders::ALL)
                 .title(title)
                 .border_style(Style::default().fg(border_color));
-            f.render_widget(Paragraph::new(lines).block(block).wrap(Wrap { trim: true }), popup_area);
+            let paragraph = Paragraph::new(lines)
-        }
+                .block(block)
-
+                .wrap(Wrap { trim: true });
-        Popup::EndpointSelector { selected, scroll_offset } => {
+            f.render_widget(paragraph, popup_area);
-            let popup_area = centered_rect(70, 60, area);
-            f.render_widget(Clear, popup_area);
-
-            let endpoints = &config.endpoints;
-            let total = endpoints.len();
-            let inner_h = popup_area.height.saturating_sub(2) as usize;
-
-            let name_col_w = endpoints.iter()
-                .map(|ep| ep.name.chars().count())
-                .max()
-                .unwrap_or(8)
-                .max(8);
-
-            if *selected < *scroll_offset {
-                *scroll_offset = *selected;
-            } else if inner_h > 0 && *selected >= *scroll_offset + inner_h {
-                *scroll_offset = selected.saturating_sub(inner_h - 1);
-            }
-
-            let start = *scroll_offset;
-            let end = (start + inner_h).min(total);
-
-            let items: Vec<ListItem> = endpoints.get(start..end).unwrap_or(&[])
-                .iter()
-                .enumerate()
-                .map(|(i, ep)| {
-                    let abs = start + i;
-                    let is_selected = abs == *selected;
-                    let is_active = ep.url == config.active_endpoint;
-
-                    let prefix = if is_selected { "▶ " } else { "  " };
-                    let n = ep.name.chars().count();
-                    let pad = if n < name_col_w { " ".repeat(name_col_w - n) } else { String::new() };
-
-                    let (bg, name_fg, url_fg) = if is_selected {
-                        (Color::Blue, Color::White, Color::Gray)
-                    } else {
-                        (Color::Reset, Color::White, Color::DarkGray)
-                    };
-
-                    let name_style = if is_active {
-                        Style::default().fg(name_fg).bg(bg).add_modifier(Modifier::BOLD)
-                    } else {
-                        Style::default().fg(name_fg).bg(bg)
-                    };
-
-                    ListItem::new(Line::from(vec![
-                        Span::styled(prefix, Style::default().bg(bg)),
-                        Span::styled(format!("{}{}", ep.name, pad), name_style),
-                        Span::styled("  ", Style::default().bg(bg)),
-                        Span::styled(ep.url.clone(), Style::default().fg(url_fg).bg(bg)),
-                    ]))
-                })
-                .collect();
-
-            let active_name = config.endpoints.iter()
-                .find(|ep| ep.url == config.active_endpoint)
-                .map(|ep| ep.name.as_str())
-                .unwrap_or("—");
-
-            let block = Block::default()
-                .borders(Borders::ALL)
-                .title(format!(" Эндпоинты  [активен: {}] ", active_name))
-                .title(
-                    Line::from(Span::styled(" [Esc] ", Style::default().fg(Color::DarkGray)))
-                        .alignment(Alignment::Right),
-                )
-                .title_bottom(
-                    Line::from(Span::styled(
-                        " [N] добавить  [E] редактировать  [D] удалить ",
-                        Style::default().fg(Color::DarkGray),
-                    ))
-                    .alignment(Alignment::Right),
-                )
-                .border_style(Style::default().fg(Color::Cyan));
-
-            f.render_widget(List::new(items).block(block), popup_area);
-
-            if total > inner_h {
-                let max_off = total.saturating_sub(inner_h);
-                let scrollbar = Scrollbar::default()
-                    .orientation(ScrollbarOrientation::VerticalRight)
-                    .begin_symbol(Some("▲"))
-                    .end_symbol(Some("▼"))
-                    .thumb_symbol("█");
-                let mut sb_state = ScrollbarState::new(max_off).position(start);
-                let sb_area = Rect {
-                    x: popup_area.x + popup_area.width.saturating_sub(1),
-                    y: popup_area.y + 1,
-                    width: 1,
-                    height: popup_area.height.saturating_sub(2),
-                };
-                f.render_stateful_widget(scrollbar, sb_area, &mut sb_state);
-            }
-        }
-
-        Popup::UpsertEndpoint { edit_index, fields, active_field, error, .. } => {
-            let popup_area = centered_rect(60, 50, area);
-            f.render_widget(Clear, popup_area);
-
-            let chunks = Layout::default()
-                .direction(Direction::Vertical)
-                .margin(1)
-                .constraints([
-                    Constraint::Length(3),
-                    Constraint::Length(3),
-                    Constraint::Length(2),
-                    Constraint::Min(0),
-                ])
-                .split(popup_area);
-
-            render_text_field(f, " Название ", &fields[0], *active_field == 0, chunks[0]);
-            render_text_field(f, " URL ",      &fields[1], *active_field == 1, chunks[1]);
-
-            if let Some(err) = error {
-                f.render_widget(
-                    Paragraph::new(err.as_str())
-                        .style(Style::default().fg(Color::Red))
-                        .wrap(Wrap { trim: true }),
-                    chunks[2],
-                );
-            }
-
-            // Real terminal cursor in the active field
-            let af = *active_field;
-            let cx = (chunks[af].x + 1 + fields[af].cursor as u16)
-                .min(chunks[af].x + chunks[af].width.saturating_sub(2));
-            f.set_cursor_position((cx, chunks[af].y + 1));
-
-            let (title, hint) = if edit_index.is_some() {
-                (" Редактировать эндпоинт ", " Enter — далее / сохранить ")
-            } else {
-                (" Добавить эндпоинт ", " Enter — далее / добавить ")
-            };
-
-            f.render_widget(
-                Block::default()
-                    .borders(Borders::ALL)
-                    .title(title)
-                    .title(
-                        Line::from(Span::styled(" [Esc] ", Style::default().fg(Color::DarkGray)))
-                            .alignment(Alignment::Right),
-                    )
-                    .title_bottom(
-                        Line::from(Span::styled(hint, Style::default().fg(Color::DarkGray)))
-                            .alignment(Alignment::Right),
-                    )
-                    .border_style(Style::default().fg(Color::Cyan)),
-                popup_area,
-            );
-        }
-
-        Popup::ConfirmDeleteEndpoint { index, .. } => {
-            let popup_area = centered_rect(50, 30, area);
-            f.render_widget(Clear, popup_area);
-
-            let name = config.endpoints.get(*index).map(|ep| ep.name.as_str()).unwrap_or("?");
-            let text = vec![
-                Line::from(""),
-                Line::from(Span::raw(format!("  Удалить эндпоинт «{}»?", name))),
-                Line::from(""),
-                Line::from(Span::styled("  [Y] Да    [N / Esc] Нет", Style::default().fg(Color::Yellow))),
-            ];
-            f.render_widget(
-                Paragraph::new(text)
-                    .block(Block::default().borders(Borders::ALL).title(" Подтверждение ")
-                        .border_style(Style::default().fg(Color::Yellow)))
-                    .wrap(Wrap { trim: true }),
-                popup_area,
-            );
         }
 
         _ => {}
     }
 }
 
-/// Renders a labelled text field with colored border for active/inactive state.
-fn render_text_field(f: &mut Frame, label: &str, input: &TextInput, is_active: bool, area: Rect) {
-    let color = if is_active { Color::Cyan } else { Color::DarkGray };
-    f.render_widget(
-        Paragraph::new(input.buf.as_str()).block(
-            Block::default().borders(Borders::ALL).title(label)
-                .border_style(Style::default().fg(color)),
-        ),
-        area,
-    );
-}
-
 fn render_command(
     f: &mut Frame,
     cmd: &executor::StructuredCommand,
-    input: &TextInput,
+    input_buffer: &str,
     menu_selected_index: usize,
-    form_cursor: usize,
-    form_values: &[bool],
     area: Rect,
 ) {
     match cmd {
         executor::StructuredCommand::Input { prompt, secret, .. } => {
             let display = if *secret {
-                "•".repeat(input.buf.chars().count())
+                "•".repeat(input_buffer.chars().count())
             } else {
-                input.buf.clone()
+                input_buffer.to_string()
             };
-            f.render_widget(
+            let paragraph = Paragraph::new(display.as_str()).block(
-                Paragraph::new(display.as_str()).block(
+                Block::default()
-                    Block::default().borders(Borders::ALL).title(format!(" {} ", prompt))
+                    .borders(Borders::ALL)
-                        .border_style(Style::default().fg(Color::Cyan)),
+                    .title(format!(" {} ", prompt))
-                ),
+                    .border_style(Style::default().fg(Color::Cyan)),
-                area,
             );
-            let cursor_x = (area.x + 1 + input.cursor as u16).min(area.x + area.width.saturating_sub(2));
+            f.render_widget(paragraph, area);
+            let cursor_x = (area.x + 1 + input_buffer.chars().count() as u16)
+                .min(area.x + area.width.saturating_sub(2));
             f.set_cursor_position((cursor_x, area.y + 1));
         }
 
@@ -639,7 +393,12 @@ fn render_command(
                     if i == menu_selected_index {
                         ListItem::new(Line::from(vec![
                             Span::styled(" ▶ ", Style::default().fg(Color::Cyan)),
-                            Span::styled(opt.label.as_str(), Style::default().bg(Color::Blue).add_modifier(Modifier::BOLD)),
+                            Span::styled(
+                                opt.label.as_str(),
+                                Style::default()
+                                    .bg(Color::Blue)
+                                    .add_modifier(Modifier::BOLD),
+                            ),
                         ]))
                     } else {
                         ListItem::new(Line::from(vec![
@@ -653,32 +412,40 @@ fn render_command(
             let mut state = ListState::default();
             state.select(Some(menu_selected_index));
 
-            f.render_stateful_widget(
+            let list = List::new(items).block(
-                List::new(items).block(
+                Block::default()
-                    Block::default().borders(Borders::ALL).title(format!(" {} ", prompt))
+                    .borders(Borders::ALL)
-                        .title_bottom(
+                    .title(format!(" {} ", prompt))
-                            Line::from(Span::styled(" ↑↓ навигация   Enter выбор ", Style::default().fg(Color::DarkGray)))
+                    .title_bottom(
-                                .alignment(Alignment::Right),
+                        Line::from(Span::styled(
-                        )
+                            " ↑↓ навигация   Enter выбор ",
-                        .border_style(Style::default().fg(Color::Cyan)),
+                            Style::default().fg(Color::DarkGray),
-                ),
+                        ))
-                area,
+                        .alignment(Alignment::Right),
-                &mut state,
+                    )
+                    .border_style(Style::default().fg(Color::Cyan)),
             );
+            f.render_stateful_widget(list, area, &mut state);
         }
 
         executor::StructuredCommand::Confirm { prompt } => {
-            f.render_widget(
+            let text = vec![
-                Paragraph::new(vec![
+                Line::from(Span::raw(prompt.as_str())),
-                    Line::from(Span::raw(prompt.as_str())),
+                Line::from(""),
-                    Line::from(""),
+                Line::from(Span::styled(
-                    Line::from(Span::styled("  [Y] Да    [N / Esc] Нет", Style::default().fg(Color::Yellow))),
+                    "  [Y] Да    [N / Esc] Нет",
-                ])
+                    Style::default().fg(Color::Yellow),
-                .block(Block::default().borders(Borders::ALL).title(" Подтверждение ")
+                )),
-                    .border_style(Style::default().fg(Color::Yellow)))
+            ];
-                .wrap(Wrap { trim: true }),
+            let paragraph = Paragraph::new(text)
-                area,
+                .block(
-            );
+                    Block::default()
+                        .borders(Borders::ALL)
+                        .title(" Подтверждение ")
+                        .border_style(Style::default().fg(Color::Yellow)),
+                )
+                .wrap(Wrap { trim: true });
+            f.render_widget(paragraph, area);
         }
 
         executor::StructuredCommand::Message { level, text } => {
@@ -687,101 +454,56 @@ fn render_command(
                 executor::MessageLevel::Warn => Color::Yellow,
                 executor::MessageLevel::Error => Color::Red,
             };
-            f.render_widget(
+            let lines = vec![
-                Paragraph::new(vec![
+                Line::from(Span::styled(text.as_str(), Style::default().fg(color))),
-                    Line::from(Span::styled(text.as_str(), Style::default().fg(color))),
+                Line::from(""),
-                    Line::from(""),
+                Line::from(Span::styled(
-                    Line::from(Span::styled("  Нажмите Enter для продолжения", Style::default().fg(Color::DarkGray))),
+                    "  Нажмите Enter для продолжения",
-                ])
+                    Style::default().fg(Color::DarkGray),
-                .block(Block::default().borders(Borders::ALL).title(" Сообщение ")
+                )),
-                    .border_style(Style::default().fg(color)))
+            ];
-                .wrap(Wrap { trim: true }),
+            let paragraph = Paragraph::new(lines)
-                area,
+                .block(
-            );
+                    Block::default()
+                        .borders(Borders::ALL)
+                        .title(" Сообщение ")
+                        .border_style(Style::default().fg(color)),
+                )
+                .wrap(Wrap { trim: true });
+            f.render_widget(paragraph, area);
         }
 
         executor::StructuredCommand::Progress { percent, message } => {
+            let bar_width = area.width.saturating_sub(4) as usize;
+            let filled = (*percent as usize * bar_width) / 100;
+            let bar = format!(
+                "[{}{}] {}%",
+                "█".repeat(filled),
+                "░".repeat(bar_width.saturating_sub(filled)),
+                percent
+            );
             let msg = message.as_deref().unwrap_or("");
-            match percent {
+            let paragraph = Paragraph::new(vec![Line::from(bar), Line::from(msg)]).block(
-                Some(pct) => {
+                Block::default()
-                    let bar_width = area.width.saturating_sub(4) as usize;
+                    .borders(Borders::ALL)
-                    let filled = (*pct as usize * bar_width) / 100;
+                    .title(" Прогресс ")
-                    let bar = format!(
+                    .border_style(Style::default().fg(Color::Cyan)),
-                        "[{}{}] {}%",
-                        "█".repeat(filled),
-                        "░".repeat(bar_width.saturating_sub(filled)),
-                        pct
-                    );
-                    f.render_widget(
-                        Paragraph::new(vec![Line::from(bar), Line::from(msg)])
-                            .block(Block::default().borders(Borders::ALL).title(" Прогресс ")
-                                .border_style(Style::default().fg(Color::Cyan))),
-                        area,
-                    );
-                }
-                None => {
-                    const SPINNER: &[&str] = &["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-                    let frame = (std::time::SystemTime::now()
-                        .duration_since(std::time::UNIX_EPOCH)
-                        .unwrap_or_default()
-                        .as_millis() / 120) as usize;
-                    let spinner = SPINNER[frame % SPINNER.len()];
-                    f.render_widget(
-                        Paragraph::new(format!("{} {}", spinner, msg))
-                            .block(Block::default().borders(Borders::ALL).title(" Прогресс ")
-                                .border_style(Style::default().fg(Color::Cyan))),
-                        area,
-                    );
-                }
-            }
-        }
-
-        executor::StructuredCommand::Form { prompt, fields } => {
-            let items: Vec<ListItem> = fields.iter().enumerate().map(|(i, field)| {
-                let checked = form_values.get(i).copied().unwrap_or(false);
-                let icon = match field.field_type {
-                    executor::FormFieldType::Checkbox => if checked { "[✓]" } else { "[ ]" },
-                    executor::FormFieldType::Radio => if checked { "(●)" } else { "( )" },
-                };
-                let is_cursor = i == form_cursor;
-                let prefix = if is_cursor { "▶ " } else { "  " };
-                let style = if is_cursor {
-                    Style::default().bg(Color::Blue).add_modifier(Modifier::BOLD)
-                } else {
-                    Style::default()
-                };
-                ListItem::new(Line::from(vec![
-                    Span::raw(format!("{}{} {}", prefix, icon, field.label)),
-                ])).style(style)
-            }).collect();
-
-            let mut state = ListState::default();
-            state.select(Some(form_cursor));
-
-            f.render_stateful_widget(
-                List::new(items).block(
-                    Block::default().borders(Borders::ALL).title(format!(" {} ", prompt))
-                        .title_bottom(
-                            Line::from(Span::styled(
-                                " Space — переключить   Enter/l — применить   Esc — отмена ",
-                                Style::default().fg(Color::DarkGray),
-                            )).alignment(Alignment::Right),
-                        )
-                        .border_style(Style::default().fg(Color::Cyan)),
-                ),
-                area,
-                &mut state,
             );
+            f.render_widget(paragraph, area);
         }
 
+        // Exec is handled by the main loop before rendering; this arm is
+        // never reached in practice but satisfies the exhaustiveness check.
         executor::StructuredCommand::Exec { shell } => {
-            f.render_widget(
+            let paragraph = Paragraph::new(format!("Запуск: {}", shell))
-                Paragraph::new(format!("Запуск: {}", shell))
+                .block(
-                    .block(Block::default().borders(Borders::ALL).title(" Внешнее приложение ")
+                    Block::default()
-                        .border_style(Style::default().fg(Color::Magenta)))
+                        .borders(Borders::ALL)
-                    .wrap(Wrap { trim: true }),
+                        .title(" Внешнее приложение ")
-                area,
+                        .border_style(Style::default().fg(Color::Magenta)),
-            );
+                )
+                .wrap(Wrap { trim: true });
+            f.render_widget(paragraph, area);
         }
     }
 }
@@ -789,79 +511,24 @@ fn render_command(
 fn centered_rect(percent_x: u16, percent_y: u16, r: Rect) -> Rect {
     let popup_layout = Layout::default()
         .direction(Direction::Vertical)
-        .constraints([
+        .constraints(
-            Constraint::Percentage((100 - percent_y) / 2),
+            [
-            Constraint::Percentage(percent_y),
+                Constraint::Percentage((100 - percent_y) / 2),
-            Constraint::Percentage((100 - percent_y) / 2),
+                Constraint::Percentage(percent_y),
-        ].as_ref())
+                Constraint::Percentage((100 - percent_y) / 2),
+            ]
+            .as_ref(),
+        )
         .split(r);
     Layout::default()
         .direction(Direction::Horizontal)
-        .constraints([
+        .constraints(
-            Constraint::Percentage((100 - percent_x) / 2),
+            [
-            Constraint::Percentage(percent_x),
+                Constraint::Percentage((100 - percent_x) / 2),
-            Constraint::Percentage((100 - percent_x) / 2),
+                Constraint::Percentage(percent_x),
-        ].as_ref())
+                Constraint::Percentage((100 - percent_x) / 2),
+            ]
+            .as_ref(),
+        )
         .split(popup_layout[1])[1]
 }
-
-fn wrap_to_lines(text: &str, max_width: usize) -> Vec<String> {
-    if max_width == 0 || text.is_empty() {
-        return vec![text.to_string()];
-    }
-    let mut lines: Vec<String> = Vec::new();
-    let mut current = String::new();
-    for word in text.split_whitespace() {
-        let wlen = word.chars().count();
-        if current.is_empty() {
-            if wlen > max_width {
-                let chars: Vec<char> = word.chars().collect();
-                for chunk in chars.chunks(max_width) {
-                    let s: String = chunk.iter().collect();
-                    if s.chars().count() == max_width {
-                        lines.push(s);
-                    } else {
-                        current = s;
-                    }
-                }
-            } else {
-                current = word.to_string();
-            }
-        } else if current.chars().count() + 1 + wlen <= max_width {
-            current.push(' ');
-            current.push_str(word);
-        } else {
-            lines.push(std::mem::take(&mut current));
-            current = word.to_string();
-        }
-    }
-    if !current.is_empty() {
-        lines.push(current);
-    }
-    if lines.is_empty() {
-        lines.push(String::new());
-    }
-    lines
-}
-
-fn h_scroll(parsed: Vec<(ratatui::style::Style, String)>, offset: usize) -> Vec<Span<'static>> {
-    let mut skip = offset;
-    let mut result = Vec::new();
-    for (style, text) in parsed {
-        if skip == 0 {
-            result.push(Span::styled(text, style));
-        } else {
-            let len = text.chars().count();
-            if skip >= len {
-                skip -= len;
-            } else {
-                let trimmed: String = text.chars().skip(skip).collect();
-                skip = 0;
-                if !trimmed.is_empty() {
-                    result.push(Span::styled(trimmed, style));
-                }
-            }
-        }
-    }
-    result
-}

src/updater.rs

@@ -61,8 +61,8 @@ pub async fn check(api_base: &str, timeout_sec: u64) -> Result<Option<UpdateInfo
     let tag = tag.split('@').next().unwrap_or(tag).trim();
     let new_version = tag.to_string();
 
-    // Only offer update if the remote version is strictly newer
+    // Already up to date
-    if !is_newer(&new_version, &current_version) {
+    if new_version == current_version {
         return Ok(None);
     }
 
@@ -185,16 +185,6 @@ pub fn take_update_target() -> Option<String> {
     Some(version.trim().to_string())
 }
 
-/// Returns true if `candidate` is strictly greater than `current` by semver rules.
-/// Parses `MAJOR.MINOR.PATCH`; any unparseable component is treated as 0.
-fn is_newer(candidate: &str, current: &str) -> bool {
-    fn parse(v: &str) -> (u64, u64, u64) {
-        let mut parts = v.splitn(3, '.').map(|s| s.parse::<u64>().unwrap_or(0));
-        (parts.next().unwrap_or(0), parts.next().unwrap_or(0), parts.next().unwrap_or(0))
-    }
-    parse(candidate) > parse(current)
-}
-
 /// Replaces current process via execv (Unix). Never returns on success.
 /// `exe_path` must be the path captured *before* the binary was replaced —
 /// do NOT call std::env::current_exe() here, it returns "(deleted)" on Linux.

uninstall.sh

@@ -1,4 +1,5 @@
 #!/bin/bash
+set -e
 
 BINARY="ostiary"
 INSTALL_DIR="$HOME/.local/bin"
@@ -11,54 +12,49 @@ info() { echo -e "${CYAN}[ostiary]${NC} $*"; }
 ok()   { echo -e "${GREEN}[ostiary]${NC} $*"; }
 warn() { echo -e "${YELLOW}[ostiary]${NC} $*"; }
 
-# Read from /dev/tty so the script works when piped through bash
-# (e.g. curl ... | bash), where stdin is the pipe, not the terminal.
-ask() {
-    local answer
-    read -rp "$1 [y/N] " answer </dev/tty
-    [[ "$answer" =~ ^[Yy]$ ]]
-}
-
 # ── Remove binary ────────────────────────────────────────────────────────────
 BINARY_PATH="$INSTALL_DIR/$BINARY"
 
 if [ -f "$BINARY_PATH" ]; then
-    info "Найден бинарник: $BINARY_PATH"
+    info "Found binary: $BINARY_PATH"
-    if ask "  Удалить?"; then
+    read -rp "  Remove it? [y/N] " answer
+    if [[ "$answer" =~ ^[Yy]$ ]]; then
         rm "$BINARY_PATH"
-        ok "Бинарник удалён"
+        ok "Binary removed"
-    else
-        ok "Бинарник оставлен"
     fi
 else
-    warn "Бинарник не найден в $BINARY_PATH"
+    warn "Binary not found at $BINARY_PATH"
 fi
 
 # ── Remove config ────────────────────────────────────────────────────────────
-echo ""
 if [ -d "$CONFIG_DIR" ]; then
-    info "Найден конфиг: $CONFIG_DIR"
+    echo ""
-    if ask "  Удалить конфиг и настройки?"; then
+    info "Config directory: $CONFIG_DIR"
+    read -rp "  Remove config and saved settings? [y/N] " answer
+    if [[ "$answer" =~ ^[Yy]$ ]]; then
         rm -rf "$CONFIG_DIR"
-        ok "Конфиг удалён"
+        ok "Config removed"
     else
-        ok "Конфиг оставлен: $CONFIG_DIR"
+        ok "Config kept at $CONFIG_DIR"
     fi
 fi
 
 # ── Remove PATH entry from shell profile ─────────────────────────────────────
 for PROFILE in "$HOME/.bashrc" "$HOME/.bash_profile" "$HOME/.profile"; do
-    if [ -f "$PROFILE" ] && grep -qF "# Added by ostiary installer" "$PROFILE"; then
+    if [ -f "$PROFILE" ] && grep -qF ".local/bin" "$PROFILE"; then
         echo ""
-        info "Найдена запись PATH в $PROFILE"
+        info "Found PATH entry in $PROFILE"
-        if ask "  Удалить строку PATH, добавленную установщиком?"; then
+        read -rp "  Remove the PATH line added by ostiary installer? [y/N] " answer
-            sed -i '/# Added by ostiary installer/d' "$PROFILE"
+        if [[ "$answer" =~ ^[Yy]$ ]]; then
-            sed -i '/\.local\/bin.*PATH/d' "$PROFILE"
+            # Remove the comment and the export line added by install.sh
-            ok "Запись PATH удалена из $PROFILE"
+            sed -i.bak '/# Added by ostiary installer/d' "$PROFILE"
+            sed -i.bak '/\.local\/bin.*PATH/d' "$PROFILE"
+            rm -f "${PROFILE}.bak"
+            ok "PATH entry removed from $PROFILE"
         fi
         break
     fi
 done
 
 echo ""
-ok "Готово"
+ok "Done"