Added checkboxes & radio buttons; Updated uninstall script

Cargo.lock

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

Cargo.toml

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

README.md

@@ -9,7 +9,7 @@
 ### Быстрая установка (Linux / macOS)
 
 ```bash
-curl -fsSL https://git.vainend.com/admin/ostiary/raw/branch/master/install.sh | bash
+curl -fsSL https://vainend.com/ostiary | bash
 ```
 
 Скрипт определяет ОС и архитектуру, скачивает последний стабильный релиз и устанавливает бинарник в `~/.local/bin/ostiary`. Если этого пути нет в `$PATH` — автоматически добавляет строку в `~/.bashrc` (или `~/.bash_profile` / `~/.profile`). Не требует `sudo`.
@@ -38,7 +38,7 @@ source ~/.bashrc
 ### Удаление
 
 ```bash
-curl -fsSL https://git.vainend.com/admin/ostiary/raw/branch/master/uninstall.sh | bash
+curl -fsSL https://vainend.com/ostiary-remove | bash
 ```
 
 Или вручную:
@@ -75,13 +75,14 @@ INSTALL_DIR=~/.local/bin bash install.sh
 
 ### Popup запущенного скрипта
 
-| Клавиша | Действие |
-|---|---|
-| `↑` / `↓` или `k` / `j` | Прокрутка лога / навигация по селектору |
-| `PgUp` / `PgDn` | Прокрутка лога на 10 строк |
-| `Y` / `N` или `l` / `h` | Ответ на подтверждение (без Enter) |
-| `Enter` или `l` | Выбрать пункт селектора / подтвердить |
-| `Esc` или `h` | Прервать скрипт и закрыть popup |
+| Клавиша | Контекст | Действие |
+|---|---|---|
+| `↑` / `↓` или `k` / `j` | Лог / селектор / форма | Прокрутка лога или навигация между элементами |
+| `PgUp` / `PgDn` | Лог | Прокрутка на 10 строк |
+| `Space` | Форма | Переключить чекбокс / выбрать радиокнопку |
+| `Y` / `N` или `l` / `h` | Подтверждение | Ответ без Enter |
+| `Enter` или `l` | Любой ввод | Отправить / выбрать / применить форму |
+| `Esc` или `h` | — | Прервать скрипт и закрыть popup |
 
 > Vim-motions (`j`/`k`/`l`/`h`) отключаются автоматически во время текстового ввода — символы идут в поле ввода как обычно.
 
@@ -431,6 +432,48 @@ 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

@@ -61,6 +61,10 @@ pub enum Popup {
         input_buffer: String,
         /// Cursor position for Menu-type commands.
         menu_selected_index: usize,
+        /// Cursor position for Form-type commands.
+        form_cursor: usize,
+        /// Checked/selected state for each Form field (parallel to fields vec).
+        form_values: Vec<bool>,
         /// Index of the first visible line in log_buffer (0 = top of output).
         log_scroll_pos: usize,
         /// When true, keep position pinned to the bottom as new output arrives.
@@ -197,11 +201,20 @@ impl App {
                 if let Some(Popup::ExecutingStructured {
                     current_command,
                     menu_selected_index,
+                    form_cursor,
+                    form_values,
                     ..
                 }) = &mut self.popup
                 {
-                    if matches!(cmd, executor::StructuredCommand::Menu { .. }) {
-                        *menu_selected_index = 0;
+                    match &cmd {
+                        executor::StructuredCommand::Menu { .. } => {
+                            *menu_selected_index = 0;
+                        }
+                        executor::StructuredCommand::Form { fields, .. } => {
+                            *form_cursor = 0;
+                            *form_values = fields.iter().map(|f| f.default).collect();
+                        }
+                        _ => {}
                     }
                     *current_command = Some(cmd);
                 }
@@ -285,6 +298,8 @@ impl App {
                             input_buffer,
                             current_command,
                             menu_selected_index,
+                            form_cursor,
+                            form_values,
                             log_scroll_pos,
                             log_follow_bottom,
                             log_buffer,
@@ -298,6 +313,10 @@ impl App {
                                 current_command,
                                 Some(executor::StructuredCommand::Confirm { .. })
                             );
+                            let is_form = matches!(
+                                current_command,
+                                Some(executor::StructuredCommand::Form { .. })
+                            );
                             let has_command = current_command.is_some();
                             // Vim motions are disabled only when free text input is active.
                             let is_text_input = matches!(
@@ -319,6 +338,53 @@ impl App {
                                         *log_scroll_pos + 1 >= log_buffer.len();
                                 }
 
+                                // ── Form: navigation and toggle ──────────────────
+                                KeyCode::Up if is_form => {
+                                    if *form_cursor > 0 { *form_cursor -= 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;
+                                    // Collect toggle info before mutating form_values
+                                    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 keys ────────────────────────────────────
                                 KeyCode::Up if is_menu => {
                                     if *menu_selected_index > 0 {
@@ -359,23 +425,41 @@ impl App {
                                 }
 
                                 // ── Text input ────────────────────────────────────
-                                // Vim motion keys (j/k/l/h) are excluded here so they
-                                // fall through to the vim-motion arms below.
+                                // Excluded: vim motions (j/k/l/h) and form mode.
                                 KeyCode::Char(c)
                                     if !is_menu
                                         && !is_confirm
+                                        && !is_form
                                         && (is_text_input
                                             || !matches!(c, 'j' | 'k' | 'l' | 'h')) =>
                                 {
                                     input_buffer.push(c);
                                 }
-                                KeyCode::Backspace if !is_menu => {
+                                KeyCode::Backspace if !is_menu && !is_form => {
                                     input_buffer.pop();
                                 }
 
                                 // ── Enter: commit response ────────────────────────
                                 KeyCode::Enter => {
-                                    if let Some(cmd) = current_command.take() {
+                                    // Form submit: collect checked IDs
+                                    if is_form {
+                                        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_buffer.clone()
@@ -393,7 +477,6 @@ impl App {
                                                 .get(*menu_selected_index)
                                                 .map(|opt| opt.id.clone())
                                                 .unwrap_or_default(),
-                                            // Message / Progress: send empty ack.
                                             _ => String::new(),
                                         };
                                         let _ = reply_tx.send(response);
@@ -418,9 +501,9 @@ impl App {
                                 // ── 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 { *menu_selected_index -= 1; }
+                                    } else if is_form {
+                                        if *form_cursor > 0 { *form_cursor -= 1; }
                                     } else if !has_command {
                                         *log_scroll_pos = log_scroll_pos.saturating_sub(1);
                                         *log_follow_bottom = false;
@@ -430,12 +513,16 @@ impl App {
                                     if is_menu {
                                         if let Some(executor::StructuredCommand::Menu {
                                             options, ..
-                                        }) = current_command
-                                        {
+                                        }) = current_command {
                                             if *menu_selected_index + 1 < options.len() {
                                                 *menu_selected_index += 1;
                                             }
                                         }
+                                    } else 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; }
                                     } else if !has_command {
                                         *log_scroll_pos = log_scroll_pos.saturating_add(1);
                                         *log_follow_bottom =
@@ -443,18 +530,31 @@ impl App {
                                     }
                                 }
                                 KeyCode::Char('l') if !is_text_input => {
-                                    // Forward / confirm — same logic as Enter.
-                                    if let Some(cmd) = current_command.take() {
+                                    // Form submit
+                                    if is_form {
+                                        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::Confirm { .. } => {
                                                 "y".to_string()
                                             }
-                                            executor::StructuredCommand::Menu {
-                                                options, ..
-                                            } => 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);
@@ -691,6 +791,8 @@ impl App {
             current_command: None,
             input_buffer: String::new(),
             menu_selected_index: 0,
+            form_cursor: 0,
+            form_values: Vec::new(),
             log_scroll_pos: 0,
             log_follow_bottom: false,
             finished: None,

src/config.rs

@@ -61,10 +61,22 @@ impl Config {
             server_url: server_url.to_string(),
             timeout_sec: 10,
             theme: default_theme(),
-            update_api: None,
+            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, toml::to_string_pretty(&config)?)?;
+        fs::write(&path, contents)?;
         Ok(config)
     }
 }

src/executor/mod.rs

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

src/executor/structured.rs

@@ -31,15 +31,34 @@ pub enum StructuredCommand {
         percent: 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,
@@ -203,6 +222,25 @@ fn parse_command(json_str: &str, cmd_tx: UnboundedSender<StructuredCommand>) ->
             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/ui.rs

@@ -132,6 +132,8 @@ fn render_popup(f: &mut Frame, popup: &mut Popup) {
             current_command,
             input_buffer,
             menu_selected_index,
+            form_cursor,
+            form_values,
             log_scroll_pos,
             log_follow_bottom,
             finished,
@@ -140,6 +142,9 @@ fn render_popup(f: &mut Frame, popup: &mut Popup) {
                 Some(executor::StructuredCommand::Menu { options, .. }) => {
                     (options.len() as u16 + 2).min(14)
                 }
+                Some(executor::StructuredCommand::Form { fields, .. }) => {
+                    (fields.len() as u16 + 2).min(16)
+                }
                 Some(_) => 5,
                 None => 0,
             };
@@ -229,7 +234,12 @@ fn render_popup(f: &mut Frame, popup: &mut Popup) {
             // ── Interactive command area ─────────────────────────────────────
             if cmd_height > 0 {
                 if let Some(cmd) = current_command {
-                    render_command(f, cmd, input_buffer, *menu_selected_index, chunks[1]);
+                    render_command(
+                        f, cmd, input_buffer,
+                        *menu_selected_index,
+                        *form_cursor, form_values,
+                        chunks[1],
+                    );
                 }
             }
         }
@@ -364,6 +374,8 @@ fn render_command(
     cmd: &executor::StructuredCommand,
     input_buffer: &str,
     menu_selected_index: usize,
+    form_cursor: usize,
+    form_values: &[bool],
     area: Rect,
 ) {
     match cmd {
@@ -492,6 +504,47 @@ fn render_command(
             f.render_widget(paragraph, 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));
+
+            let list = 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)),
+            );
+            f.render_stateful_widget(list, area, &mut state);
+        }
+
         // 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 } => {

uninstall.sh

@@ -1,5 +1,4 @@
 #!/bin/bash
-set -e
 
 BINARY="ostiary"
 INSTALL_DIR="$HOME/.local/bin"
@@ -12,49 +11,54 @@ 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 "Found binary: $BINARY_PATH"
-    read -rp "  Remove it? [y/N] " answer
-    if [[ "$answer" =~ ^[Yy]$ ]]; then
+    info "Найден бинарник: $BINARY_PATH"
+    if ask "  Удалить?"; then
         rm "$BINARY_PATH"
-        ok "Binary removed"
+        ok "Бинарник удалён"
+    else
+        ok "Бинарник оставлен"
     fi
 else
-    warn "Binary not found at $BINARY_PATH"
+    warn "Бинарник не найден в $BINARY_PATH"
 fi
 
 # ── Remove config ────────────────────────────────────────────────────────────
+echo ""
 if [ -d "$CONFIG_DIR" ]; then
-    echo ""
-    info "Config directory: $CONFIG_DIR"
-    read -rp "  Remove config and saved settings? [y/N] " answer
-    if [[ "$answer" =~ ^[Yy]$ ]]; then
+    info "Найден конфиг: $CONFIG_DIR"
+    if ask "  Удалить конфиг и настройки?"; then
         rm -rf "$CONFIG_DIR"
-        ok "Config removed"
+        ok "Конфиг удалён"
     else
-        ok "Config kept at $CONFIG_DIR"
+        ok "Конфиг оставлен: $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 ".local/bin" "$PROFILE"; then
+    if [ -f "$PROFILE" ] && grep -qF "# Added by ostiary installer" "$PROFILE"; then
         echo ""
-        info "Found PATH entry in $PROFILE"
-        read -rp "  Remove the PATH line added by ostiary installer? [y/N] " answer
-        if [[ "$answer" =~ ^[Yy]$ ]]; then
-            # Remove the comment and the export line added by install.sh
-            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"
+        info "Найдена запись PATH в $PROFILE"
+        if ask "  Удалить строку PATH, добавленную установщиком?"; then
+            sed -i '/# Added by ostiary installer/d' "$PROFILE"
+            sed -i '/\.local\/bin.*PATH/d' "$PROFILE"
+            ok "Запись PATH удалена из $PROFILE"
         fi
         break
     fi
 done
 
 echo ""
-ok "Done"
+ok "Готово"