aline-ai 0.6.3__py3-none-any.whl → 0.6.5__py3-none-any.whl

realign/dashboard/app.py

@@ -5,7 +5,6 @@ import subprocess
 import sys
 import time
 import traceback
-from pathlib import Path
 
 from textual.app import App, ComposeResult
 from textual.binding import Binding
@@ -16,10 +15,7 @@ from .widgets import (
     AlineHeader,
     WatcherPanel,
     WorkerPanel,
-    SessionsTable,
-    EventsTable,
     ConfigPanel,
-    SearchPanel,
     TerminalPanel,
 )
 
@@ -71,9 +67,6 @@ class AlineDashboard(App):
         Binding("n", "page_next", "Next Page", show=False),
         Binding("p", "page_prev", "Prev Page", show=False),
         Binding("s", "switch_view", "Switch View", show=False),
-        Binding("c", "create_event", "Create Event", show=False),
-        Binding("l", "load_context", "Load Context", show=False),
-        Binding("y", "share_import", "Share Import", show=False),
         Binding("ctrl+c", "quit_confirm", "Quit", priority=True),
     ]
 
@@ -119,14 +112,8 @@ class AlineDashboard(App):
                         yield WatcherPanel()
                     with TabPane("Worker", id="worker"):
                         yield WorkerPanel()
-                with TabPane("Contexts", id="sessions"):
-                    yield SessionsTable()
-                with TabPane("Share", id="events"):
-                    yield EventsTable()
                 with TabPane("Config", id="config"):
                     yield ConfigPanel()
-                with TabPane("Search", id="search"):
-                    yield SearchPanel()
             yield Footer()
             logger.debug("compose() completed successfully")
         except Exception as e:
@@ -135,8 +122,8 @@ class AlineDashboard(App):
 
     def _tab_ids(self) -> list[str]:
         if self.dev_mode:
-            return ["terminal", "watcher", "worker", "sessions", "events", "config", "search"]
-        return ["terminal", "sessions", "events", "config", "search"]
+            return ["terminal", "watcher", "worker", "config"]
+        return ["terminal", "config"]
 
     def on_mount(self) -> None:
         """Apply theme based on system settings and watch for changes."""
@@ -222,14 +209,8 @@ class AlineDashboard(App):
             self.query_one(WatcherPanel).refresh_data()
         elif active_tab_id == "worker":
             self.query_one(WorkerPanel).refresh_data()
-        elif active_tab_id == "sessions":
-            self.query_one(SessionsTable).refresh_data()
-        elif active_tab_id == "events":
-            self.query_one(EventsTable).refresh_data()
         elif active_tab_id == "config":
             self.query_one(ConfigPanel).refresh_data()
-        elif active_tab_id == "search":
-            pass  # Search is manual
         elif active_tab_id == "terminal":
             await self.query_one(TerminalPanel).refresh_data()
 
@@ -242,7 +223,6 @@ class AlineDashboard(App):
             self.query_one(WatcherPanel).action_next_page()
         elif active_tab_id == "worker":
             self.query_one(WorkerPanel).action_next_page()
-        # sessions and events tabs use scrolling instead of pagination
 
     def action_page_prev(self) -> None:
         """Go to previous page in current panel."""
@@ -253,7 +233,6 @@ class AlineDashboard(App):
             self.query_one(WatcherPanel).action_prev_page()
         elif active_tab_id == "worker":
             self.query_one(WorkerPanel).action_prev_page()
-        # sessions and events tabs use scrolling instead of pagination
 
     def action_switch_view(self) -> None:
         """Switch view in current panel (if supported)."""
@@ -264,10 +243,6 @@ class AlineDashboard(App):
             self.query_one(WatcherPanel).action_switch_view()
         elif active_tab_id == "worker":
             self.query_one(WorkerPanel).action_switch_view()
-        elif active_tab_id == "sessions":
-            self.query_one(SessionsTable).action_switch_view()
-        elif active_tab_id == "events":
-            self.query_one(EventsTable).action_switch_view()
 
     def action_help(self) -> None:
         """Show help information."""
@@ -286,128 +261,6 @@ class AlineDashboard(App):
         self._quit_confirm_deadline = now + self._quit_confirm_window_s
         self.notify("Press Ctrl+C again to quit", title="Quit", timeout=2)
 
-    def action_create_event(self) -> None:
-        """Create an event from selected sessions (Sessions tab only)."""
-        tabbed_content = self.query_one(TabbedContent)
-        if tabbed_content.active != "sessions":
-            self.notify(
-                "Switch to the Sessions tab to create an event", title="Create Event", timeout=3
-            )
-            return
-
-        sessions_panel = self.query_one(SessionsTable)
-        session_ids = sessions_panel.get_selected_session_ids()
-        if not session_ids:
-            self.notify(
-                "No sessions selected (use space / cmd-click / shift-click)",
-                title="Create Event",
-                timeout=3,
-            )
-            return
-
-        from .screens import CreateEventScreen
-
-        self.push_screen(CreateEventScreen(session_ids))
-
-    def action_share_import(self) -> None:
-        """Import a share URL (Events tab only)."""
-        tabbed_content = self.query_one(TabbedContent)
-        if tabbed_content.active != "events":
-            self.notify(
-                "Switch to the Events tab to import a share", title="Share Import", timeout=3
-            )
-            return
-
-        from .screens import ShareImportScreen
-
-        self.push_screen(ShareImportScreen())
-
-    async def action_load_context(self) -> None:
-        """Load selected sessions/events into the active Claude terminal context."""
-        tabbed_content = self.query_one(TabbedContent)
-        active_tab_id = tabbed_content.active
-
-        try:
-            from . import tmux_manager
-
-            context_id = tmux_manager.get_active_claude_context_id()
-        except Exception:
-            context_id = None
-
-        if not context_id:
-            self.notify(
-                "No active Claude context found. Use the Terminal tab and select a 'cc' terminal (New cc).",
-                title="Load Context",
-                severity="warning",
-                timeout=4,
-            )
-            return
-
-        sessions: list[str] = []
-        events: list[str] = []
-
-        if active_tab_id == "sessions":
-            sessions = self.query_one(SessionsTable).get_selected_session_ids()
-            if not sessions:
-                self.notify(
-                    "No sessions selected (use space / cmd-click / shift-click)",
-                    title="Load Context",
-                    severity="warning",
-                    timeout=3,
-                )
-                return
-        elif active_tab_id == "events":
-            events = self.query_one(EventsTable).get_selected_event_ids()
-            if not events:
-                self.notify(
-                    "No events selected (use space / cmd-click / shift-click)",
-                    title="Load Context",
-                    severity="warning",
-                    timeout=3,
-                )
-                return
-        else:
-            self.notify(
-                "Switch to Sessions or Events to load selection into context",
-                title="Load Context",
-                timeout=3,
-            )
-            return
-
-        try:
-            from ..context import add_context
-
-            add_context(
-                sessions=sessions or None,
-                events=events or None,
-                context_id=context_id,
-            )
-        except Exception as e:
-            self.notify(
-                f"Failed to load context: {e}",
-                title="Load Context",
-                severity="error",
-                timeout=4,
-            )
-            return
-
-        try:
-            from .widgets.terminal_panel import TerminalPanel
-
-            if TerminalPanel.supported():
-                await self.query_one(TerminalPanel).refresh_data()
-        except Exception:
-            pass
-
-        parts: list[str] = []
-        if sessions:
-            parts.append(f"{len(sessions)} sessions")
-        if events:
-            parts.append(f"{len(events)} events")
-        what = ", ".join(parts) if parts else "selection"
-        self.notify(f"Loaded {what} into {context_id}", title="Load Context", timeout=3)
-
-
 def run_dashboard(use_native_terminal: bool | None = None) -> None:
     """Run the Aline Dashboard.
 

realign/dashboard/tmux_manager.py

@@ -195,11 +195,17 @@ def _session_id_from_transcript_path(transcript_path: str | None) -> str | None:
 
 def _load_terminal_state_from_db() -> dict[str, dict[str, str]]:
     """Load terminal state from database (best-effort)."""
+    import time as _time
+    t0 = _time.time()
     try:
         from ..db import get_database
 
+        t1 = _time.time()
         db = get_database(read_only=True)
+        logger.info(f"[PERF] _load_terminal_state_from_db get_database: {_time.time() - t1:.3f}s")
+        t2 = _time.time()
         agents = db.list_agents(status="active", limit=100)
+        logger.info(f"[PERF] _load_terminal_state_from_db list_agents: {_time.time() - t2:.3f}s")
 
         out: dict[str, dict[str, str]] = {}
         for agent in agents:
@@ -510,14 +516,43 @@ def bootstrap_dashboard_into_tmux() -> None:
     os.execvp("tmux", ["tmux", "-L", OUTER_SOCKET, "attach", "-t", OUTER_SESSION])
 
 
+_inner_session_configured = False
+
+
 def ensure_inner_session() -> bool:
-    """Ensure the inner tmux server/session exists (returns True on success)."""
+    """Ensure the inner tmux server/session exists (returns True on success).
+
+    The full configuration (mouse, status bar, border styles, home window setup) is
+    only applied once per process lifetime.  Subsequent calls just verify the session
+    is still alive via a cheap ``has-session`` check.
+    """
+    global _inner_session_configured
+
     if not (tmux_available() and in_tmux() and managed_env_enabled()):
         return False
 
     if _run_inner_tmux(["has-session", "-t", INNER_SESSION]).returncode != 0:
-        if _run_inner_tmux(["new-session", "-d", "-s", INNER_SESSION]).returncode != 0:
+        # Create a stable "home" window so user-created terminals can use names like "zsh"
+        # without always becoming "zsh-2".
+        if (
+            _run_inner_tmux(["new-session", "-d", "-s", INNER_SESSION, "-n", "home"]).returncode
+            != 0
+        ):
             return False
+        # Force re-configuration after creating a new session.
+        _inner_session_configured = False
+
+    if _inner_session_configured:
+        return True
+
+    # --- One-time configuration below ---
+
+    # Ensure the default/home window stays named "home" (tmux auto-rename would otherwise
+    # change it to "zsh"/"opencode" depending on the last foreground command).
+    try:
+        _ensure_inner_home_window()
+    except Exception:
+        pass
 
     # Dedicated inner server; safe to enable mouse globally there.
     _run_inner_tmux(["set-option", "-g", "mouse", "on"])
@@ -534,9 +569,104 @@ def ensure_inner_session() -> bool:
     _run_inner_tmux(["set-option", "-g", "pane-border-indicators", "arrows"])
 
     _source_aline_tmux_config(_run_inner_tmux)
+
+    _inner_session_configured = True
     return True
 
 
+def _ensure_inner_home_window() -> None:
+    """Ensure the inner session has a reserved, non-renaming 'home' window (best-effort)."""
+    if _run_inner_tmux(["has-session", "-t", INNER_SESSION]).returncode != 0:
+        return
+
+    out = (
+        _run_inner_tmux(
+            [
+                "list-windows",
+                "-t",
+                INNER_SESSION,
+                "-F",
+                "#{window_id}\t#{window_index}\t#{window_name}\t#{"
+                + OPT_TERMINAL_ID
+                + "}\t#{"
+                + OPT_PROVIDER
+                + "}\t#{"
+                + OPT_SESSION_TYPE
+                + "}\t#{"
+                + OPT_CONTEXT_ID
+                + "}\t#{"
+                + OPT_CREATED_AT
+                + "}\t#{"
+                + OPT_NO_TRACK
+                + "}",
+            ],
+            capture=True,
+        ).stdout
+        or ""
+    )
+
+    candidates: list[tuple[str, int, str, str, str, str, str, str, str]] = []
+    for line in _parse_lines(out):
+        parts = (line.split("\t", 8) + [""] * 9)[:9]
+        window_id = parts[0]
+        try:
+            window_index = int(parts[1])
+        except Exception:
+            window_index = 9999
+        window_name = parts[2]
+        terminal_id = parts[3]
+        provider = parts[4]
+        session_type = parts[5]
+        context_id = parts[6]
+        created_at = parts[7]
+        no_track = parts[8]
+
+        # Pick an unmanaged window (the default one created by `new-session`) as "home".
+        unmanaged = (
+            not (terminal_id or "").strip()
+            and not (provider or "").strip()
+            and not (session_type or "").strip()
+            and not (context_id or "").strip()
+            and not (created_at or "").strip()
+        )
+        if unmanaged:
+            candidates.append(
+                (
+                    window_id,
+                    window_index,
+                    window_name,
+                    terminal_id,
+                    provider,
+                    session_type,
+                    context_id,
+                    created_at,
+                    no_track,
+                )
+            )
+
+    if not candidates:
+        return
+
+    # Prefer the first window (index 0) if present.
+    candidates.sort(key=lambda t: t[1])
+    window_id = candidates[0][0]
+
+    # Rename to "home" and prevent tmux auto-renaming it based on foreground command.
+    _run_inner_tmux(["rename-window", "-t", window_id, "home"])
+    _run_inner_tmux(["set-option", "-w", "-t", window_id, "automatic-rename", "off"])
+    _run_inner_tmux(["set-option", "-w", "-t", window_id, "allow-rename", "off"])
+
+    # Mark as internal/no-track so UI can hide it.
+    # NOTE: We use _run_inner_tmux directly here instead of set_inner_window_options
+    # to avoid recursion: set_inner_window_options → ensure_inner_session →
+    # _ensure_inner_home_window → set_inner_window_options.
+    try:
+        _run_inner_tmux(["set-option", "-w", "-t", window_id, OPT_NO_TRACK, "1"])
+        _run_inner_tmux(["set-option", "-w", "-t", window_id, OPT_CREATED_AT, str(time.time())])
+    except Exception:
+        pass
+
+
 def ensure_right_pane(width_percent: int = 50) -> bool:
     """Create the right-side pane (terminal area) if it doesn't exist.
 
@@ -580,9 +710,14 @@ def ensure_right_pane(width_percent: int = 50) -> bool:
 
 
 def list_inner_windows() -> list[InnerWindow]:
+    import time as _time
+    t0 = _time.time()
     if not ensure_inner_session():
         return []
+    logger.info(f"[PERF] list_inner_windows ensure_inner_session: {_time.time() - t0:.3f}s")
+    t1 = _time.time()
     state = _load_terminal_state()
+    logger.info(f"[PERF] list_inner_windows _load_terminal_state: {_time.time() - t1:.3f}s")
     out = (
         _run_inner_tmux(
             [
@@ -678,13 +813,16 @@ def list_inner_windows() -> list[InnerWindow]:
 
 
 def set_inner_window_options(window_id: str, options: dict[str, str]) -> bool:
+    import time as _time
     if not ensure_inner_session():
         return False
     ok = True
     for key, value in options.items():
+        t0 = _time.time()
         # Important: these are per-window (not session-wide) to avoid cross-tab clobbering.
         if _run_inner_tmux(["set-option", "-w", "-t", window_id, key, value]).returncode != 0:
             ok = False
+        logger.info(f"[PERF] set_inner_window_options {key}: {_time.time() - t0:.3f}s")
     return ok
 
 
@@ -701,16 +839,24 @@ def create_inner_window(
     terminal_id: str | None = None,
     provider: str | None = None,
     context_id: str | None = None,
+    no_track: bool = False,
 ) -> InnerWindow | None:
+    import time as _time
+    t0 = _time.time()
+    logger.info(f"[PERF] create_inner_window START")
     if not ensure_right_pane():
         return None
+    logger.info(f"[PERF] create_inner_window ensure_right_pane: {_time.time() - t0:.3f}s")
 
+    t1 = _time.time()
     existing = list_inner_windows()
+    logger.info(f"[PERF] create_inner_window list_inner_windows: {_time.time() - t1:.3f}s")
     name = _unique_name((w.window_name for w in existing), base_name)
 
     # Record creation time before creating the window
     created_at = time.time()
 
+    t2 = _time.time()
     proc = _run_inner_tmux(
         [
             "new-window",
@@ -725,6 +871,7 @@ def create_inner_window(
         ],
         capture=True,
     )
+    logger.info(f"[PERF] create_inner_window new-window: {_time.time() - t2:.3f}s")
     if proc.returncode != 0:
         return None
 
@@ -744,7 +891,13 @@ def create_inner_window(
     opts.setdefault(OPT_SESSION_TYPE, "")
     opts.setdefault(OPT_SESSION_ID, "")
     opts.setdefault(OPT_TRANSCRIPT_PATH, "")
+    if no_track:
+        opts[OPT_NO_TRACK] = "1"
+    else:
+        opts.setdefault(OPT_NO_TRACK, "")
+    t3 = _time.time()
     set_inner_window_options(window_id, opts)
+    logger.info(f"[PERF] create_inner_window set_options: {_time.time() - t3:.3f}s")
 
     _run_inner_tmux(["select-window", "-t", window_id])
 
@@ -784,6 +937,16 @@ def clear_attention(window_id: str) -> bool:
 
 def get_active_claude_context_id() -> str | None:
     """Return the active inner tmux window's Claude ALINE_CONTEXT_ID (if any)."""
+    return get_active_context_id(allowed_providers={"claude"})
+
+
+def get_active_codex_context_id() -> str | None:
+    """Return the active inner tmux window's Codex ALINE_CONTEXT_ID (if any)."""
+    return get_active_context_id(allowed_providers={"codex"})
+
+
+def get_active_context_id(*, allowed_providers: set[str] | None = None) -> str | None:
+    """Return the active inner tmux window's ALINE_CONTEXT_ID (optionally filtered by provider)."""
     try:
         windows = list_inner_windows()
     except Exception:
@@ -793,9 +956,12 @@ def get_active_claude_context_id() -> str | None:
     if active is None:
         return None
 
-    is_claude = (active.provider == "claude") or (active.session_type == "claude")
-    if not is_claude:
-        return None
+    if allowed_providers is not None:
+        allowed = {str(p).strip() for p in allowed_providers if str(p).strip()}
+        provider = (active.provider or "").strip()
+        session_type = (active.session_type or "").strip()
+        if provider not in allowed and session_type not in allowed:
+            return None
 
     context_id = (active.context_id or "").strip()
     return context_id or None

realign/dashboard/widgets/config_panel.py

@@ -89,6 +89,30 @@ class ConfigPanel(Static):
         height: auto;
         margin-top: 2;
     }
+
+    ConfigPanel .terminal-settings {
+        height: auto;
+        margin-top: 2;
+    }
+
+    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:
@@ -97,6 +121,7 @@ class ConfigPanel(Static):
         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."""
@@ -115,6 +140,15 @@ class ConfigPanel(Static):
                     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")
@@ -129,6 +163,9 @@ class ConfigPanel(Static):
         # Query and set the actual tmux border resize state
         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)
 
@@ -151,6 +188,9 @@ class ConfigPanel(Static):
             # 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."""
@@ -318,27 +358,67 @@ class ConfigPanel(Static):
         except Exception as e:
             self.app.notify(f"Error toggling border resize: {e}", title="Tmux", severity="error")
 
+    def _sync_auto_close_stale_radio(self) -> None:
+        """Sync radio buttons with config file setting."""
+        try:
+            config = ReAlignConfig.load()
+            is_enabled = config.auto_close_stale_terminals
+            self._auto_close_stale_enabled = is_enabled
+
+            # 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 _toggle_auto_close_stale(self, enabled: bool) -> None:
+        """Enable or disable auto-close stale terminals setting."""
+        try:
+            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")
+
     def _handle_doctor(self) -> None:
-        """Run aline doctor command in background."""
+        """Run aline doctor directly in background thread."""
         self.app.notify("Running Aline Doctor...", title="Doctor")
 
         def do_doctor():
             try:
-                import subprocess
-                result = subprocess.run(
-                    ["aline", "doctor"],
-                    capture_output=True,
-                    text=True,
-                    timeout=60,
-                )
-                if result.returncode == 0:
+                import contextlib
+                import io
+                from ...commands.doctor import run_doctor
+
+                # Suppress Rich console output (would corrupt TUI)
+                with contextlib.redirect_stdout(io.StringIO()), contextlib.redirect_stderr(io.StringIO()):
+                    exit_code = run_doctor(
+                        restart_daemons=True,
+                        start_if_not_running=False,
+                        verbose=False,
+                        clear_cache=True,
+                        auto_fix=True,
+                    )
+
+                if exit_code == 0:
                     self.app.call_from_thread(
                         self.app.notify, "Doctor completed successfully", title="Doctor"
                     )
                 else:
-                    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"
+                        self.app.notify, "Doctor completed with errors", title="Doctor", severity="error"
                     )
             except Exception as e:
                 self.app.call_from_thread(

realign/dashboard/widgets/sessions_table.py

@@ -17,7 +17,7 @@ from textual.binding import Binding
 from textual.containers import Container, Horizontal, Vertical
 from textual.reactive import reactive
 from textual.worker import Worker, WorkerState
-from textual.widgets import Button, DataTable, Static
+from textual.widgets import Button, DataTable, Select, Static
 
 from ...logging_config import setup_logger
 from .openable_table import OpenableDataTable