aline-ai 0.6.2__py3-none-any.whl → 0.6.4__py3-none-any.whl

realign/dashboard/widgets/config_panel.py

@@ -1,22 +1,17 @@
 """Config Panel Widget for viewing and editing configuration."""
 
 import threading
-import webbrowser
-from dataclasses import fields
-from pathlib import Path
-from typing import Optional
 
 from textual.app import ComposeResult
-from textual.containers import Horizontal, Vertical
-from textual.widgets import Button, DataTable, Input, Static, Switch
+from textual.containers import Horizontal
+from textual.widgets import Button, RadioButton, RadioSet, Static
 
-from ..tmux_manager import _run_outer_tmux, OUTER_SESSION
+from ..tmux_manager import _run_outer_tmux
 from ...auth import (
     load_credentials,
     save_credentials,
     clear_credentials,
     open_login_page,
-    is_logged_in,
     get_current_user,
     find_free_port,
     start_callback_server,
@@ -37,184 +32,171 @@ class ConfigPanel(Static):
         padding: 1;
     }
 
-    ConfigPanel .config-path {
-        margin-bottom: 1;
-    }
-
     ConfigPanel .section-title {
         text-style: bold;
         margin-bottom: 1;
     }
 
-    ConfigPanel DataTable {
-        height: 1fr;
-        max-height: 20;
-    }
-
-    ConfigPanel .edit-section {
-        height: 5;
+    ConfigPanel .button-row {
+        height: 3;
         margin-top: 1;
-        padding: 1;
-        border: solid $primary;
     }
 
-    ConfigPanel .edit-section Input {
-        width: 1fr;
+    ConfigPanel .button-row Button {
+        margin-right: 1;
     }
 
-    ConfigPanel .button-row {
+    ConfigPanel .account-section {
         height: 3;
-        margin-top: 1;
+        align: left middle;
     }
 
-    ConfigPanel .button-row Button {
+    ConfigPanel .account-section .account-label {
+        width: auto;
+        margin-right: 1;
+    }
+
+    ConfigPanel .account-section .account-email {
+        width: auto;
         margin-right: 1;
     }
 
     ConfigPanel .tmux-settings {
         height: auto;
-        margin-top: 1;
-        padding: 1;
-        border: solid $secondary;
+        margin-top: 2;
     }
 
     ConfigPanel .tmux-settings .setting-row {
-        height: 3;
-        align: left middle;
+        height: auto;
     }
 
     ConfigPanel .tmux-settings .setting-label {
         width: auto;
-        margin-right: 1;
     }
 
-    ConfigPanel .tmux-settings Switch {
+    ConfigPanel .tmux-settings RadioSet {
         width: auto;
+        height: auto;
+        layout: horizontal;
     }
 
-    ConfigPanel .account-section {
+    ConfigPanel .tmux-settings RadioButton {
+        width: auto;
+        margin-right: 2;
+    }
+
+    ConfigPanel .tools-section {
         height: auto;
-        margin-top: 1;
-        padding: 1;
-        border: solid $success;
+        margin-top: 2;
     }
 
-    ConfigPanel .account-section .account-status {
-        margin-bottom: 1;
+    ConfigPanel .terminal-settings {
+        height: auto;
+        margin-top: 2;
     }
 
-    ConfigPanel .account-section Button {
-        margin-right: 1;
+    ConfigPanel .terminal-settings .setting-row {
+        height: auto;
+    }
+
+    ConfigPanel .terminal-settings .setting-label {
+        width: auto;
+    }
+
+    ConfigPanel .terminal-settings RadioSet {
+        width: auto;
+        height: auto;
+        layout: horizontal;
+    }
+
+    ConfigPanel .terminal-settings RadioButton {
+        width: auto;
+        margin-right: 2;
     }
     """
 
     def __init__(self) -> None:
         super().__init__()
-        self._config_path: Optional[Path] = None
-        self._config_data: dict = {}
-        self._selected_key: Optional[str] = None
         self._border_resize_enabled: bool = True  # Track tmux border resize state
-        self._syncing_switch: bool = False  # Flag to prevent recursive switch updates
+        self._syncing_radio: bool = False  # Flag to prevent recursive radio updates
         self._login_in_progress: bool = False  # Track login state
         self._refresh_timer = None  # Timer for auto-refresh
+        self._auto_close_stale_enabled: bool = False  # Track auto-close setting
 
     def compose(self) -> ComposeResult:
         """Compose the config panel layout."""
-        yield Static(id="config-path", classes="config-path")
-        yield Static("[bold]Configuration[/bold]", classes="section-title")
-        yield DataTable(id="config-table")
-        with Horizontal(classes="edit-section"):
-            yield Static("Selected: ", id="selected-label")
-            yield Input(id="edit-input", placeholder="Select a config item to edit...")
-        with Horizontal(classes="button-row"):
-            yield Button("Save", id="save-btn", variant="primary")
-            yield Button("Reload", id="reload-btn", variant="default")
-
         # Account section
-        with Static(classes="account-section"):
-            yield Static("[bold]Account[/bold]", classes="section-title")
-            yield Static(id="account-status", classes="account-status")
-            with Horizontal(classes="button-row"):
-                yield Button("Login", id="login-btn", variant="primary")
-                yield Button("Logout", id="logout-btn", variant="warning")
+        with Horizontal(classes="account-section"):
+            yield Static("[bold]Account:[/bold]", classes="account-label")
+            yield Static(id="account-email", classes="account-email")
+            yield Button("Login", id="auth-btn", variant="primary")
 
         # Tmux settings section
         with Static(classes="tmux-settings"):
             yield Static("[bold]Tmux Settings[/bold]", classes="section-title")
             with Horizontal(classes="setting-row"):
-                yield Static("Allow border resize:", classes="setting-label")
-                yield Switch(value=True, id="border-resize-switch")
+                yield Static("Border resize:", classes="setting-label")
+                with RadioSet(id="border-resize-radio"):
+                    yield RadioButton("Enabled", id="border-resize-enabled", value=True)
+                    yield RadioButton("Disabled", id="border-resize-disabled")
+
+        # Terminal settings section
+        with Static(classes="terminal-settings"):
+            yield Static("[bold]Terminal Settings[/bold]", classes="section-title")
+            with Horizontal(classes="setting-row"):
+                yield Static("Auto-close stale terminals (24h):", classes="setting-label")
+                with RadioSet(id="auto-close-stale-radio"):
+                    yield RadioButton("Enabled", id="auto-close-stale-enabled")
+                    yield RadioButton("Disabled", id="auto-close-stale-disabled", value=True)
+
+        # Tools section
+        with Static(classes="tools-section"):
+            yield Static("[bold]Tools[/bold]", classes="section-title")
+            with Horizontal(classes="button-row"):
+                yield Button("Aline Doctor", id="doctor-btn", variant="default")
 
     def on_mount(self) -> None:
         """Set up the panel on mount."""
-        table = self.query_one("#config-table", DataTable)
-        table.add_columns("Setting", "Value")
-        table.cursor_type = "row"
-
-        # Load initial data
-        self.refresh_data()
-
         # Update account status display
         self._update_account_status()
 
         # Query and set the actual tmux border resize state
-        self._sync_border_resize_switch()
+        self._sync_border_resize_radio()
+
+        # Sync auto-close stale terminals setting from config
+        self._sync_auto_close_stale_radio()
 
         # Start timer to periodically refresh account status (every 5 seconds)
         self._refresh_timer = self.set_interval(5.0, self._update_account_status)
 
-    def on_data_table_row_selected(self, event: DataTable.RowSelected) -> None:
-        """Handle row selection in the config table."""
-        table = self.query_one("#config-table", DataTable)
-
-        # Get the selected row data
-        row_key = event.row_key
-        if row_key is not None:
-            row_data = table.get_row(row_key)
-            if row_data and len(row_data) >= 2:
-                key = str(row_data[0])
-                value = str(row_data[1])
-
-                self._selected_key = key
-
-                # Update the edit section
-                selected_label = self.query_one("#selected-label", Static)
-                selected_label.update(f"Selected: [bold]{key}[/bold]")
-
-                edit_input = self.query_one("#edit-input", Input)
-                # Don't show masked values in input
-                if "api_key" in key and value.endswith("..."):
-                    edit_input.value = ""
-                    edit_input.placeholder = "(enter new API key)"
-                else:
-                    edit_input.value = value
-
     def on_button_pressed(self, event: Button.Pressed) -> None:
         """Handle button clicks."""
-        if event.button.id == "save-btn":
-            self._save_config()
-        elif event.button.id == "reload-btn":
-            self.refresh_data()
-            self._update_account_status()
-            self.app.notify("Configuration reloaded", title="Config")
-        elif event.button.id == "login-btn":
-            self._handle_login()
-        elif event.button.id == "logout-btn":
-            self._handle_logout()
-
-    def on_switch_changed(self, event: Switch.Changed) -> None:
-        """Handle switch toggle events."""
-        if self._syncing_switch:
+        if event.button.id == "auth-btn":
+            credentials = get_current_user()
+            if credentials:
+                self._handle_logout()
+            else:
+                self._handle_login()
+        elif event.button.id == "doctor-btn":
+            self._handle_doctor()
+
+    def on_radio_set_changed(self, event: RadioSet.Changed) -> None:
+        """Handle radio set change events."""
+        if self._syncing_radio:
             return  # Ignore events during sync
-        if event.switch.id == "border-resize-switch":
-            self._toggle_border_resize(event.value)
+        if event.radio_set.id == "border-resize-radio":
+            # Check which radio button is selected
+            enabled = event.pressed.id == "border-resize-enabled"
+            self._toggle_border_resize(enabled)
+        elif event.radio_set.id == "auto-close-stale-radio":
+            enabled = event.pressed.id == "auto-close-stale-enabled"
+            self._toggle_auto_close_stale(enabled)
 
     def _update_account_status(self) -> None:
         """Update the account status display."""
         try:
-            status_widget = self.query_one("#account-status", Static)
-            login_btn = self.query_one("#login-btn", Button)
-            logout_btn = self.query_one("#logout-btn", Button)
+            email_widget = self.query_one("#account-email", Static)
+            auth_btn = self.query_one("#auth-btn", Button)
         except Exception:
             # Widget not ready yet
             return
@@ -225,15 +207,14 @@ class ConfigPanel(Static):
 
         credentials = get_current_user()
         if credentials:
-            status_widget.update(
-                f"[green]Logged in as:[/green] [bold]{credentials.email}[/bold]"
-            )
-            login_btn.disabled = True
-            logout_btn.disabled = False
+            email_widget.update(f"[bold]{credentials.email}[/bold]")
+            auth_btn.label = "Logout"
+            auth_btn.variant = "warning"
         else:
-            status_widget.update("[yellow]Not logged in[/yellow]")
-            login_btn.disabled = False
-            logout_btn.disabled = True
+            email_widget.update("[dim]Not logged in[/dim]")
+            auth_btn.label = "Login"
+            auth_btn.variant = "primary"
+        auth_btn.disabled = False
 
     def _handle_login(self) -> None:
         """Handle login button click - start login flow in background."""
@@ -244,10 +225,10 @@ class ConfigPanel(Static):
         self._login_in_progress = True
 
         # Update UI to show login in progress
-        login_btn = self.query_one("#login-btn", Button)
-        login_btn.disabled = True
-        status_widget = self.query_one("#account-status", Static)
-        status_widget.update("[cyan]Opening browser for login...[/cyan]")
+        auth_btn = self.query_one("#auth-btn", Button)
+        auth_btn.disabled = True
+        email_widget = self.query_one("#account-email", Static)
+        email_widget.update("[cyan]Opening browser...[/cyan]")
 
         # Start login flow in background thread
         def do_login():
@@ -332,8 +313,8 @@ class ConfigPanel(Static):
         else:
             self.app.notify("Failed to logout", title="Account", severity="error")
 
-    def _sync_border_resize_switch(self) -> None:
-        """Query tmux state and sync the switch to match."""
+    def _sync_border_resize_radio(self) -> None:
+        """Query tmux state and sync the radio buttons to match."""
         try:
             # Check if MouseDrag1Border is bound by listing keys
             result = _run_outer_tmux(["list-keys", "-T", "root"], capture=True)
@@ -343,13 +324,16 @@ class ConfigPanel(Static):
             is_enabled = "MouseDrag1Border" in output
             self._border_resize_enabled = is_enabled
 
-            # Update switch without triggering the toggle action
-            self._syncing_switch = True
+            # Update radio buttons without triggering the toggle action
+            self._syncing_radio = True
             try:
-                switch = self.query_one("#border-resize-switch", Switch)
-                switch.value = is_enabled
+                if is_enabled:
+                    radio = self.query_one("#border-resize-enabled", RadioButton)
+                else:
+                    radio = self.query_one("#border-resize-disabled", RadioButton)
+                radio.value = True
             finally:
-                self._syncing_switch = False
+                self._syncing_radio = False
         except Exception:
             # If we can't query, assume enabled (default tmux behavior)
             pass
@@ -374,120 +358,70 @@ class ConfigPanel(Static):
         except Exception as e:
             self.app.notify(f"Error toggling border resize: {e}", title="Tmux", severity="error")
 
-    def _save_config(self) -> None:
-        """Save the edited configuration."""
-        if not self._selected_key:
-            self.app.notify("No config item selected", title="Config", severity="warning")
-            return
-
-        edit_input = self.query_one("#edit-input", Input)
-        new_value = edit_input.value
-
+    def _sync_auto_close_stale_radio(self) -> None:
+        """Sync radio buttons with config file setting."""
         try:
-            from ...config import ReAlignConfig
-
             config = ReAlignConfig.load()
-            key = self._selected_key
-
-            # Validate and convert value
-            if not hasattr(config, key):
-                self.app.notify(f"Unknown config key: {key}", title="Config", severity="error")
-                return
-
-            # Type conversion
-            field_type = ReAlignConfig.__annotations__.get(key)
-            if field_type is int:
-                new_value = int(new_value)
-            elif field_type is float:
-                new_value = float(new_value)
-            elif field_type is bool:
-                new_value = new_value.lower() in ("true", "1", "yes")
-
-            # Special validation for llm_provider
-            if key == "llm_provider" and new_value not in ("auto", "claude", "openai"):
-                self.app.notify(
-                    "Invalid llm_provider value. Use: auto, claude, openai",
-                    title="Config",
-                    severity="error",
-                )
-                return
-
-            setattr(config, key, new_value)
-            config.save()
-
-            self.app.notify(f"Saved: {key}", title="Config")
-            self.refresh_data()
-
-        except Exception as e:
-            self.app.notify(f"Error saving config: {e}", title="Config", severity="error")
+            is_enabled = config.auto_close_stale_terminals
+            self._auto_close_stale_enabled = is_enabled
 
-    def refresh_data(self) -> None:
-        """Refresh configuration data."""
-        self._load_config()
-        self._update_display()
+            # Update radio buttons without triggering the toggle action
+            self._syncing_radio = True
+            try:
+                if is_enabled:
+                    radio = self.query_one("#auto-close-stale-enabled", RadioButton)
+                else:
+                    radio = self.query_one("#auto-close-stale-disabled", RadioButton)
+                radio.value = True
+            finally:
+                self._syncing_radio = False
+        except Exception:
+            pass
 
-    def _load_config(self) -> None:
-        """Load configuration from file."""
+    def _toggle_auto_close_stale(self, enabled: bool) -> None:
+        """Enable or disable auto-close stale terminals setting."""
         try:
-            from ...config import ReAlignConfig
-
-            self._config_path = Path.home() / ".aline" / "config.yaml"
             config = ReAlignConfig.load()
+            config.auto_close_stale_terminals = enabled
+            config.save()
+            self._auto_close_stale_enabled = enabled
+            if enabled:
+                self.app.notify("Auto-close stale terminals enabled", title="Terminal")
+            else:
+                self.app.notify("Auto-close stale terminals disabled", title="Terminal")
+        except Exception as e:
+            self.app.notify(f"Error saving setting: {e}", title="Config", severity="error")
 
-            self._config_data = {}
-            for field in fields(ReAlignConfig):
-                key = field.name
-                value = getattr(config, key)
-
-                # Mask API keys for display
-                if "api_key" in key and value:
-                    if len(str(value)) > 8:
-                        value = str(value)[:4] + "..." + str(value)[-4:]
-                    else:
-                        value = "***"
-
-                self._config_data[key] = value
+    def _handle_doctor(self) -> None:
+        """Run aline doctor command in background."""
+        self.app.notify("Running Aline Doctor...", title="Doctor")
 
-        except Exception as e:
-            self._config_data = {"error": str(e)}
-
-    def _update_display(self) -> None:
-        """Update the display with current data."""
-        # Update config path
-        path_widget = self.query_one("#config-path", Static)
-        if self._config_path:
-            path_widget.update(f"[bold]Config file:[/bold] {self._config_path}")
-        else:
-            path_widget.update("[bold]Config file:[/bold] (not found)")
-
-        # Update table
-        table = self.query_one("#config-table", DataTable)
-        table.clear()
-
-        for key, value in self._config_data.items():
-            # Color-code certain values
-            if key == "llm_provider":
-                if value == "auto":
-                    value_display = "[cyan]auto[/cyan]"
-                elif value == "claude":
-                    value_display = "[yellow]claude[/yellow]"
-                elif value == "openai":
-                    value_display = "[green]openai[/green]"
+        def do_doctor():
+            try:
+                import subprocess
+                result = subprocess.run(
+                    ["aline", "doctor"],
+                    capture_output=True,
+                    text=True,
+                    timeout=60,
+                )
+                if result.returncode == 0:
+                    self.app.call_from_thread(
+                        self.app.notify, "Doctor completed successfully", title="Doctor"
+                    )
                 else:
-                    value_display = str(value)
-            elif isinstance(value, bool):
-                value_display = "[green]true[/green]" if value else "[red]false[/red]"
-            elif "api_key" in key and value and value != "None":
-                value_display = f"[dim]{value}[/dim]"
-            else:
-                value_display = str(value) if value is not None else "[dim]None[/dim]"
+                    error_msg = result.stderr.strip() if result.stderr else "Unknown error"
+                    self.app.call_from_thread(
+                        self.app.notify, f"Doctor failed: {error_msg}", title="Doctor", severity="error"
+                    )
+            except Exception as e:
+                self.app.call_from_thread(
+                    self.app.notify, f"Doctor error: {e}", title="Doctor", severity="error"
+                )
 
-            table.add_row(key, value_display)
+        thread = threading.Thread(target=do_doctor, daemon=True)
+        thread.start()
 
-        # Reset edit section
-        selected_label = self.query_one("#selected-label", Static)
-        selected_label.update("Selected: (none)")
-        edit_input = self.query_one("#edit-input", Input)
-        edit_input.value = ""
-        edit_input.placeholder = "Select a config item to edit..."
-        self._selected_key = None
+    def refresh_data(self) -> None:
+        """Refresh account status (called by app refresh action)."""
+        self._update_account_status()