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

realign/dashboard/tmux_manager.py

@@ -516,9 +516,21 @@ def ensure_inner_session() -> bool:
         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
 
+    # 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"])
 
@@ -537,6 +549,101 @@ def ensure_inner_session() -> bool:
     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.
+    try:
+        set_inner_window_options(
+            window_id,
+            {
+                OPT_NO_TRACK: "1",
+                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.
 
@@ -701,6 +808,7 @@ def create_inner_window(
     terminal_id: str | None = None,
     provider: str | None = None,
     context_id: str | None = None,
+    no_track: bool = False,
 ) -> InnerWindow | None:
     if not ensure_right_pane():
         return None
@@ -744,6 +852,10 @@ 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, "")
     set_inner_window_options(window_id, opts)
 
     _run_inner_tmux(["select-window", "-t", window_id])
@@ -784,6 +896,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 +915,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,6 +358,40 @@ 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."""
         self.app.notify("Running Aline Doctor...", title="Doctor")

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