glaip-sdk 0.6.2__py3-none-any.whl → 0.6.4__py3-none-any.whl

glaip_sdk/cli/slash/tui/accounts_app.py

@@ -13,17 +13,27 @@ import asyncio
 import logging
 from collections.abc import Callable
 from dataclasses import dataclass
-
-from glaip_sdk.cli.slash.accounts_shared import build_account_status_string
+from typing import Any
+
+from glaip_sdk.cli.account_store import AccountStore, AccountStoreError, get_account_store
+from glaip_sdk.cli.commands.common_config import check_connection_with_reason
+from glaip_sdk.cli.slash.accounts_shared import (
+    build_account_rows,
+    build_account_status_string,
+    env_credentials_present,
+)
 from glaip_sdk.cli.slash.tui.background_tasks import BackgroundTaskMixin
 from glaip_sdk.cli.slash.tui.loading import hide_loading_indicator, show_loading_indicator
+from glaip_sdk.cli.validators import validate_api_key
+from glaip_sdk.utils.validation import validate_url
 
 try:  # pragma: no cover - optional dependency
     from textual import events
     from textual.app import App, ComposeResult
     from textual.binding import Binding
     from textual.containers import Container, Horizontal, Vertical
-    from textual.widgets import DataTable, Footer, Header, Input, LoadingIndicator, Static
+    from textual.screen import ModalScreen
+    from textual.widgets import Button, Checkbox, DataTable, Footer, Header, Input, LoadingIndicator, Static
 except Exception:  # pragma: no cover - optional dependency
     events = None  # type: ignore[assignment]
     App = None  # type: ignore[assignment]
@@ -32,20 +42,37 @@ except Exception:  # pragma: no cover - optional dependency
     Container = None  # type: ignore[assignment]
     Horizontal = None  # type: ignore[assignment]
     Vertical = None  # type: ignore[assignment]
+    Button = None  # type: ignore[assignment]
+    Checkbox = None  # type: ignore[assignment]
     DataTable = None  # type: ignore[assignment]
     Footer = None  # type: ignore[assignment]
     Header = None  # type: ignore[assignment]
     Input = None  # type: ignore[assignment]
     LoadingIndicator = None  # type: ignore[assignment]
+    ModalScreen = None  # type: ignore[assignment]
     Static = None  # type: ignore[assignment]
 
 TEXTUAL_SUPPORTED = App is not None and DataTable is not None
 
+# Use safe bases so the module remains importable without Textual installed.
+if TEXTUAL_SUPPORTED:
+    _AccountFormBase = ModalScreen[dict[str, Any] | None]
+    _ConfirmDeleteBase = ModalScreen[str | None]
+    _AppBase = App[None]
+else:
+    _AccountFormBase = object
+    _ConfirmDeleteBase = object
+    _AppBase = object
+
 # Widget IDs for Textual UI
 ACCOUNTS_TABLE_ID = "#accounts-table"
 FILTER_INPUT_ID = "#filter-input"
 STATUS_ID = "#status"
 ACCOUNTS_LOADING_ID = "#accounts-loading"
+FORM_KEY_ID = "#form-key"
+
+# CSS file name
+CSS_FILE_NAME = "accounts.tcss"
 
 
 @dataclass
@@ -55,6 +82,119 @@ class AccountsTUICallbacks:
     switch_account: Callable[[str], tuple[bool, str]]
 
 
+def _build_account_rows_from_store(
+    store: AccountStore,
+    env_lock: bool,
+) -> tuple[list[dict[str, str | bool]], str | None]:
+    """Load account rows with masking and active flag."""
+    accounts = store.list_accounts()
+    active = store.get_active_account()
+    rows = build_account_rows(accounts, active, env_lock)
+    return rows, active
+
+
+def _prepare_account_payload(
+    *,
+    name: str,
+    api_url_input: str,
+    api_key_input: str,
+    existing_url: str | None,
+    existing_key: str | None,
+    existing_names: set[str],
+    mode: str,
+    should_test: bool,
+    validate_name: Callable[[str], None],
+    connection_tester: Callable[[str, str], tuple[bool, str]],
+) -> tuple[dict[str, Any] | None, str | None]:
+    """Validate and build payload for add/edit operations."""
+    name = name.strip()
+    api_url_raw = api_url_input.strip()
+    api_key_raw = api_key_input.strip()
+
+    error = _validate_account_name(name, existing_names, mode, validate_name)
+    if error:
+        return None, error
+
+    api_url_candidate = api_url_raw or (existing_url or "")
+    api_key_candidate = api_key_raw or (existing_key or "")
+
+    api_url_validated, error = _validate_and_prepare_url(api_url_candidate)
+    if error:
+        return None, error
+
+    api_key_validated, error = _validate_and_prepare_key(api_key_candidate)
+    if error:
+        return None, error
+
+    if should_test:
+        error = _test_connection(api_url_validated, api_key_validated, connection_tester)
+        if error:
+            return None, error
+
+    payload: dict[str, Any] = {
+        "name": name,
+        "api_url": api_url_validated,
+        "api_key": api_key_validated,
+        "should_test": should_test,
+        "mode": mode,
+    }
+    return payload, None
+
+
+def _validate_account_name(
+    name: str,
+    existing_names: set[str],
+    mode: str,
+    validate_name: Callable[[str], None],
+) -> str | None:
+    """Validate account name."""
+    if not name:
+        return "Account name cannot be empty."
+
+    try:
+        validate_name(name)
+    except Exception as exc:
+        return str(exc)
+
+    if mode == "add" and name in existing_names:
+        return f"Account '{name}' already exists. Choose a unique name."
+
+    return None
+
+
+def _validate_and_prepare_url(api_url_candidate: str) -> tuple[str, str | None]:
+    """Validate and prepare API URL."""
+    if not api_url_candidate:
+        return "", "API URL is required."
+    try:
+        return validate_url(api_url_candidate), None
+    except Exception as exc:
+        return "", str(exc)
+
+
+def _validate_and_prepare_key(api_key_candidate: str) -> tuple[str, str | None]:
+    """Validate and prepare API key."""
+    if not api_key_candidate:
+        return "", "API key is required."
+    try:
+        return validate_api_key(api_key_candidate), None
+    except Exception as exc:
+        return "", str(exc)
+
+
+def _test_connection(
+    api_url: str,
+    api_key: str,
+    connection_tester: Callable[[str, str], tuple[bool, str]],
+) -> str | None:
+    """Test API connection."""
+    ok, reason = connection_tester(api_url, api_key)
+    if not ok:
+        detail = reason or "connection_failed"
+        return f"Connection test failed: {detail}"
+    return None
+
+
 def run_accounts_textual(
     rows: list[dict[str, str | bool]],
     *,
@@ -69,14 +209,182 @@ def run_accounts_textual(
     app.run()
 
 
-class AccountsTextualApp(BackgroundTaskMixin, App[None]):  # pragma: no cover - interactive
+class AccountFormModal(_AccountFormBase):  # pragma: no cover - interactive
+    """Modal form for add/edit account."""
+
+    CSS_PATH = CSS_FILE_NAME
+
+    def __init__(
+        self,
+        *,
+        mode: str,
+        existing: dict[str, str] | None,
+        existing_names: set[str],
+        connection_tester: Callable[[str, str], tuple[bool, str]],
+        validate_name: Callable[[str], None],
+    ) -> None:
+        """Initialize the account form modal.
+
+        Args:
+            mode: Form mode, either "add" or "edit".
+            existing: Existing account data for edit mode.
+            existing_names: Set of existing account names for validation.
+            connection_tester: Callable to test API connection.
+            validate_name: Callable to validate account name.
+        """
+        super().__init__()
+        self._mode = mode
+        self._existing = existing or {}
+        self._existing_names = existing_names
+        self._connection_tester = connection_tester
+        self._validate_name = validate_name
+
+    def compose(self) -> ComposeResult:
+        """Render the form controls."""
+        title = "Add account" if self._mode == "add" else "Edit account"
+        name_input = Input(
+            value=self._existing.get("name", ""),
+            placeholder="account-name",
+            id="form-name",
+            disabled=self._mode == "edit",
+        )
+        url_input = Input(value=self._existing.get("api_url", ""), placeholder="https://api.example.com", id="form-url")
+        key_input = Input(value="", placeholder="sk-...", password=True, id="form-key")
+        test_checkbox = Checkbox(
+            "Test connection before save",
+            value=True,
+            id="form-test",
+        )
+        status = Static("", id="form-status")
+
+        yield Static(title, id="form-title")
+        yield Static("Name", classes="form-label")
+        yield name_input
+        yield Static("API URL", classes="form-label")
+        yield url_input
+        yield Static("API Key", classes="form-label")
+        yield key_input
+        yield Horizontal(
+            Button("Show key", id="toggle-key"),
+            Button("Clear key", id="clear-key"),
+            id="form-key-actions",
+        )
+        yield test_checkbox
+        yield Horizontal(
+            Button("Save", id="form-save", variant="primary"),
+            Button("Cancel", id="form-cancel"),
+            id="form-actions",
+        )
+        yield status
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handle button presses."""
+        btn_id = event.button.id or ""
+        if btn_id == "form-cancel":
+            self.dismiss(None)
+            return
+        if btn_id == "toggle-key":
+            key_input = self.query_one(FORM_KEY_ID, Input)
+            key_input.password = not key_input.password
+            key_input.focus()
+            return
+        if btn_id == "clear-key":
+            key_input = self.query_one(FORM_KEY_ID, Input)
+            key_input.value = ""
+            key_input.focus()
+            return
+        if btn_id == "form-save":
+            self._handle_submit()
+
+    def _handle_submit(self) -> None:
+        """Validate inputs and dismiss with payload on success."""
+        status = self.query_one("#form-status", Static)
+        name_input = self.query_one("#form-name", Input)
+        url_input = self.query_one("#form-url", Input)
+        key_input = self.query_one(FORM_KEY_ID, Input)
+        test_checkbox = self.query_one("#form-test", Checkbox)
+
+        payload, error = _prepare_account_payload(
+            name=name_input.value or "",
+            api_url_input=url_input.value or "",
+            api_key_input=key_input.value or "",
+            existing_url=self._existing.get("api_url"),
+            existing_key=self._existing.get("api_key"),
+            existing_names=self._existing_names,
+            mode=self._mode,
+            should_test=bool(test_checkbox.value),
+            validate_name=self._validate_name,
+            connection_tester=self._connection_tester,
+        )
+        if error:
+            status.update(f"[red]{error}[/]")
+            if error.startswith("Connection test failed") and hasattr(self.app, "_set_status"):
+                try:
+                    # Surface a status-bar cue so errors remain visible after closing the modal.
+                    self.app._set_status(error, "yellow")  # type: ignore[attr-defined]
+                except Exception:
+                    pass
+            return
+        status.update("[green]Saving...[/]")
+        self.dismiss(payload)
+
+
+class ConfirmDeleteModal(_ConfirmDeleteBase):  # pragma: no cover - interactive
+    """Modal requiring typed confirmation for delete."""
+
+    CSS_PATH = CSS_FILE_NAME
+
+    def __init__(self, name: str) -> None:
+        """Initialize the delete confirmation modal.
+
+        Args:
+            name: Name of the account to delete.
+        """
+        super().__init__()
+        self._name = name
+
+    def compose(self) -> ComposeResult:
+        """Render confirmation form."""
+        yield Static(f"Type '{self._name}' to confirm deletion. This cannot be undone.", id="confirm-text")
+        yield Input(placeholder=self._name, id="confirm-input")
+        yield Horizontal(
+            Button("Delete", id="confirm-delete", variant="error"),
+            Button("Cancel", id="confirm-cancel"),
+            id="confirm-actions",
+        )
+        yield Static("", id="confirm-status")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handle confirmation buttons."""
+        btn_id = event.button.id or ""
+        if btn_id == "confirm-cancel":
+            self.dismiss(None)
+            return
+        if btn_id == "confirm-delete":
+            self._handle_confirm()
+
+    def _handle_confirm(self) -> None:
+        """Dismiss with name when confirmation matches."""
+        status = self.query_one("#confirm-status", Static)
+        input_widget = self.query_one("#confirm-input", Input)
+        if (input_widget.value or "").strip() != self._name:
+            status.update(f"[yellow]Name does not match; type '{self._name}' to confirm.[/]")
+            input_widget.focus()
+            return
+        self.dismiss(self._name)
+
+
+class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - interactive
     """Textual application for browsing accounts."""
 
-    CSS_PATH = "accounts.tcss"
+    CSS_PATH = CSS_FILE_NAME
     BINDINGS = [
         Binding("enter", "switch_row", "Switch", show=True),
         Binding("return", "switch_row", "Switch", show=False),
         Binding("/", "focus_filter", "Filter", show=True),
+        Binding("a", "add_account", "Add", show=True),
+        Binding("e", "edit_account", "Edit", show=True),
+        Binding("d", "delete_account", "Delete", show=True),
         # Esc clears filter when focused/non-empty; otherwise exits
         Binding("escape", "clear_or_exit", "Close", priority=True),
         Binding("q", "app_exit", "Close", priority=True),
@@ -98,6 +406,7 @@ class AccountsTextualApp(BackgroundTaskMixin, App[None]):  # pragma: no cover -
             callbacks: Callbacks for account switching operations.
         """
         super().__init__()
+        self._store = get_account_store()
         self._all_rows = rows
         self._active_account = active_account
         self._env_lock = env_lock
@@ -111,12 +420,15 @@ class AccountsTextualApp(BackgroundTaskMixin, App[None]):  # pragma: no cover -
         yield Static(header_text, id="header-info")
         if self._env_lock:
             yield Static(
-                "Env credentials detected (AIP_API_URL/AIP_API_KEY); switching is disabled.",
+                "Env credentials detected (AIP_API_URL/AIP_API_KEY); add/edit/delete are disabled.",
                 id="env-lock",
             )
-        filter_bar = Container(
+        clear_btn = Button("Clear", id="filter-clear")
+        clear_btn.display = False  # hide until filter has content
+        filter_bar = Horizontal(
             Static("Filter (/):", id="filter-label"),
             Input(placeholder="Type to filter by name or host", id="filter-input"),
+            clear_btn,
             id="filter-container",
         )
         filter_bar.styles.padding = (0, 0)
@@ -151,6 +463,7 @@ class AccountsTextualApp(BackgroundTaskMixin, App[None]):  # pragma: no cover -
         # Keep the filter tight to the table
         main = self.query_one(Vertical)
         main.styles.gap = 0
+        self._update_filter_button_visibility()
 
     def _header_text(self) -> str:
         """Build header text with active account and host."""
@@ -221,29 +534,15 @@ class AccountsTextualApp(BackgroundTaskMixin, App[None]):  # pragma: no cover -
         self._reload_rows()
         table = self.query_one(ACCOUNTS_TABLE_ID, DataTable)
         table.focus()
+        self._update_filter_button_visibility()
 
     def on_input_changed(self, event: Input.Changed) -> None:
         """Apply filter live as the user types."""
         self._filter_text = (event.value or "").strip()
         self._reload_rows()
+        self._update_filter_button_visibility()
 
-    def on_key(self, event: events.Key) -> None:  # type: ignore[override]
-        """Let users start typing to filter without pressing '/' first."""
-        if not getattr(event, "is_printable", False):
-            return
-        if not event.character:
-            return
-        filter_input = self.query_one(FILTER_INPUT_ID, Input)
-        if filter_input.has_focus:
-            return
-        filter_input.focus()
-        filter_input.value = (filter_input.value or "") + event.character
-        filter_input.cursor_position = len(filter_input.value)
-        self._filter_text = filter_input.value.strip()
-        self._reload_rows()
-        event.stop()
-
-    def _reload_rows(self) -> None:
+    def _reload_rows(self, preferred_name: str | None = None) -> None:
         """Refresh table rows based on current filter/active state."""
         # Work on a copy to avoid mutating the backing rows list
         rows_copy = [dict(row) for row in self._all_rows]
@@ -268,8 +567,9 @@ class AccountsTextualApp(BackgroundTaskMixin, App[None]):  # pragma: no cover -
             )
         # Move cursor to active or first row
         cursor_idx = 0
+        target_name = preferred_name or self._active_account
         for idx, row in enumerate(filtered):
-            if row.get("name") == self._active_account:
+            if row.get("name") == target_name:
                 cursor_idx = idx
                 break
         if filtered:
@@ -326,6 +626,13 @@ class AccountsTextualApp(BackgroundTaskMixin, App[None]):  # pragma: no cover -
         """Hide the loading indicator."""
         hide_loading_indicator(self, ACCOUNTS_LOADING_ID)
 
+    def _clear_filter(self) -> None:
+        """Clear the filter input and reset filter state."""
+        filter_input = self.query_one(FILTER_INPUT_ID, Input)
+        filter_input.value = ""
+        self._filter_text = ""
+        self._update_filter_button_visibility()
+
     def _queue_switch(self, name: str) -> None:
         """Run switch in background to keep UI responsive."""
 
@@ -362,18 +669,204 @@ class AccountsTextualApp(BackgroundTaskMixin, App[None]):  # pragma: no cover -
         header.update(self._header_text())
 
     def action_clear_or_exit(self) -> None:
-        """Clear filter when focused/non-empty; otherwise exit.
+        """Clear or exit filter when focused; otherwise exit app.
 
         UX note: helps users reset the list without leaving the TUI.
         """
         filter_input = self.query_one(FILTER_INPUT_ID, Input)
-        # Extract nested conditional into clear statement
-        should_clear = filter_input.has_focus and (filter_input.value or self._filter_text)
-        if should_clear:
-            filter_input.value = ""
-            self._filter_text = ""
-            self._reload_rows()
+        if filter_input.has_focus:
+            # Clear when there is text; otherwise just move focus back to the table
+            if filter_input.value or self._filter_text:
+                self._clear_filter()
+                self._reload_rows()
             table = self.query_one(ACCOUNTS_TABLE_ID, DataTable)
             table.focus()
             return
         self.exit()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handle filter bar buttons."""
+        if event.button.id == "filter-clear":
+            self._clear_filter()
+            self._reload_rows()
+            table = self.query_one(ACCOUNTS_TABLE_ID, DataTable)
+            table.focus()
+
+    def action_add_account(self) -> None:
+        """Open add account modal."""
+        if self._check_env_lock_hotkey():
+            return
+        if self._should_block_actions():
+            return
+        existing_names = {str(row.get("name", "")) for row in self._all_rows}
+        modal = AccountFormModal(
+            mode="add",
+            existing=None,
+            existing_names=existing_names,
+            connection_tester=lambda url, key: check_connection_with_reason(url, key, abort_on_error=False),
+            validate_name=self._store.validate_account_name,
+        )
+        self.push_screen(modal, self._on_form_result)
+
+    def action_edit_account(self) -> None:
+        """Open edit account modal for selected row."""
+        if self._check_env_lock_hotkey():
+            return
+        if self._should_block_actions():
+            return
+        name = self._get_selected_name()
+        if not name:
+            self._set_status("Select an account to edit.", "yellow")
+            return
+        account = self._store.get_account(name)
+        if not account:
+            self._set_status(f"Account '{name}' not found.", "red")
+            return
+        existing_names = {str(row.get("name", "")) for row in self._all_rows if str(row.get("name", "")) != name}
+        modal = AccountFormModal(
+            mode="edit",
+            existing={"name": name, "api_url": account.get("api_url", ""), "api_key": account.get("api_key", "")},
+            existing_names=existing_names,
+            connection_tester=lambda url, key: check_connection_with_reason(url, key, abort_on_error=False),
+            validate_name=self._store.validate_account_name,
+        )
+        self.push_screen(modal, self._on_form_result)
+
+    def action_delete_account(self) -> None:
+        """Open delete confirmation modal."""
+        if self._check_env_lock_hotkey():
+            return
+        if self._should_block_actions():
+            return
+        name = self._get_selected_name()
+        if not name:
+            self._set_status("Select an account to delete.", "yellow")
+            return
+        accounts = self._store.list_accounts()
+        if len(accounts) <= 1:
+            self._set_status("Cannot remove the last remaining account.", "red")
+            return
+        self.push_screen(ConfirmDeleteModal(name), self._on_delete_result)
+
+    def _check_env_lock_hotkey(self) -> bool:
+        """Prevent mutations when env credentials are present."""
+        if not self._is_env_locked():
+            return False
+        self._env_lock = True
+        self._set_status("Disabled by env-lock.", "yellow")
+        # Refresh UI to reflect env-lock state (header/banners/rows)
+        self._refresh_rows(preferred_name=self._active_account)
+        return True
+
+    def _on_form_result(self, payload: dict[str, Any] | None) -> None:
+        """Handle add/edit modal result."""
+        if payload is None:
+            self._set_status("Edit/add cancelled.", "yellow")
+            return
+        self._save_account(payload)
+
+    def _on_delete_result(self, confirmed_name: str | None) -> None:
+        """Handle delete confirmation result."""
+        if not confirmed_name:
+            self._set_status("Delete cancelled.", "yellow")
+            return
+        try:
+            self._store.remove_account(confirmed_name)
+        except AccountStoreError as exc:
+            self._set_status(f"Delete failed: {exc}", "red")
+            return
+        except Exception as exc:  # pragma: no cover - defensive
+            self._set_status(f"Unexpected delete error: {exc}", "red")
+            return
+
+        self._set_status(f"Account '{confirmed_name}' deleted.", "green")
+        # Clear filter before refresh to show all accounts
+        self._clear_filter()
+        # Refresh rows without preferred name to show all accounts
+        # Active account will be cleared if the deleted account was active
+        self._refresh_rows(preferred_name=None)
+        table = self.query_one(ACCOUNTS_TABLE_ID, DataTable)
+        table.focus()
+
+    def _save_account(self, payload: dict[str, Any]) -> None:
+        """Persist account data from modal payload."""
+        if self._is_env_locked():
+            self._set_status("Disabled by env-lock.", "yellow")
+            return
+
+        name = str(payload.get("name", ""))
+        api_url = str(payload.get("api_url", ""))
+        api_key = str(payload.get("api_key", ""))
+        set_active = bool(payload.get("set_active", payload.get("mode") == "add"))
+        is_edit = payload.get("mode") == "edit"
+
+        try:
+            self._store.add_account(name, api_url, api_key, overwrite=is_edit)
+        except AccountStoreError as exc:
+            self._set_status(f"Save failed: {exc}", "red")
+            return
+        except Exception as exc:  # pragma: no cover - defensive
+            self._set_status(f"Unexpected save error: {exc}", "red")
+            return
+
+        if set_active:
+            try:
+                self._store.set_active_account(name)
+                self._active_account = name
+            except Exception as exc:  # pragma: no cover - defensive
+                self._set_status(f"Saved but could not set active: {exc}", "yellow")
+            else:
+                self._announce_active_change(name)
+                self._update_header()
+
+        self._set_status(f"Account '{name}' saved.", "green")
+        # Clear filter before refresh to show all accounts
+        self._clear_filter()
+        # Refresh rows with preferred name to highlight the saved account
+        self._refresh_rows(preferred_name=name)
+        # Return focus to the table for immediate hotkey use
+        table = self.query_one(ACCOUNTS_TABLE_ID, DataTable)
+        table.focus()
+
+    def _refresh_rows(self, preferred_name: str | None = None) -> None:
+        """Reload rows from store and preserve filter/cursor."""
+        self._env_lock = self._is_env_locked()
+        self._all_rows, self._active_account = _build_account_rows_from_store(self._store, self._env_lock)
+        self._reload_rows(preferred_name=preferred_name)
+        self._update_header()
+
+    def _get_selected_name(self) -> str | None:
+        """Return selected account name, if any."""
+        table = self.query_one(ACCOUNTS_TABLE_ID, DataTable)
+        if table.cursor_row is None:
+            return None
+        try:
+            row = table.get_row_at(table.cursor_row)
+        except Exception:
+            return None
+        return str(row[0]) if row else None
+
+    def _is_env_locked(self) -> bool:
+        """Return True when env credentials are set (even partially)."""
+        return env_credentials_present(partial=True)
+
+    def _announce_active_change(self, name: str) -> None:
+        """Surface active account change in status bar."""
+        account = self._store.get_account(name) or {}
+        host = account.get("api_url", "")
+        host_suffix = f" • {host}" if host else ""
+        self._set_status(f"Active account ➜ {name}{host_suffix}", "green")
+
+    def _should_block_actions(self) -> bool:
+        """Return True when mutating hotkeys are blocked by filter focus."""
+        filter_input = self.query_one(FILTER_INPUT_ID, Input)
+        if filter_input.has_focus:
+            self._set_status("Exit filter (Esc or Clear) to add/edit/delete.", "yellow")
+            return True
+        return False
+
+    def _update_filter_button_visibility(self) -> None:
+        """Show clear button only when filter has content."""
+        filter_input = self.query_one(FILTER_INPUT_ID, Input)
+        clear_btn = self.query_one("#filter-clear", Button)
+        clear_btn.display = bool(filter_input.value or self._filter_text)

glaip_sdk/cli/slash/tui/remote_runs_app.py

@@ -284,13 +284,13 @@ class RemoteRunsTextualApp(App[None]):
             "Duration",
             "Input Preview",
         )
-        yield table
-        yield Horizontal(
+        yield table  # pragma: no cover - interactive UI, tested via integration
+        yield Horizontal(  # pragma: no cover - interactive UI, tested via integration
             LoadingIndicator(id=RUNS_LOADING_ID),
             Static(id="status"),
             id="status-bar",
         )
-        yield Footer()
+        yield Footer()  # pragma: no cover - interactive UI, tested via integration
 
     def on_mount(self) -> None:
         """Render the initial page."""