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

realign/dashboard/widgets/terminal_panel.py

@@ -15,7 +15,9 @@ import asyncio
 import os
 import re
 import shlex
+import time
 import traceback
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Callable, Union
 
@@ -385,13 +387,175 @@ class TerminalPanel(Container, can_focus=True):
             # Native terminal: check provider
             return w.provider == "claude"
 
-        # tmux: check window name and tags
         window_name = (w.window_name or "").strip().lower()
+        if re.fullmatch(r"codex(?:-\d+)?", window_name or ""):
+            return False
+
+        # tmux: prefer explicit provider/session_type tags
+        if (w.provider or w.session_type):
+            return (w.provider == "claude") or (w.session_type == "claude")
+
+        # tmux: fallback to window name heuristic
         if re.fullmatch(r"cc(?:-\d+)?", window_name or ""):
             return True
+        return False
+
+    @staticmethod
+    def _is_codex_window(w: WindowData) -> bool:
+        """Check if a window is a Codex terminal."""
+        if isinstance(w, TerminalInfo):
+            return w.provider == "codex"
+
+        # tmux: prefer explicit provider/session_type tags
+        if (w.provider or w.session_type):
+            return (w.provider == "codex") or (w.session_type == "codex")
+
+        window_name = (w.window_name or "").strip().lower()
+        if re.fullmatch(r"codex(?:-\d+)?", window_name or ""):
+            return True
+
+        return False
+
+    @classmethod
+    def _supports_context(cls, w: WindowData) -> bool:
+        return cls._is_claude_window(w) or cls._is_codex_window(w)
+
+    @staticmethod
+    def _is_internal_tmux_window(w: tmux_manager.InnerWindow) -> bool:
+        """Hide internal tmux windows (e.g., the reserved 'home' window)."""
+        if not w.no_track:
+            return False
+        if (w.window_name or "").strip().lower() != "home":
+            return False
+        return not any(
+            (
+                (w.terminal_id or "").strip(),
+                (w.provider or "").strip(),
+                (w.session_type or "").strip(),
+                (w.session_id or "").strip(),
+                (w.context_id or "").strip(),
+                (w.transcript_path or "").strip(),
+                (w.attention or "").strip(),
+            )
+        )
+
+    def _maybe_link_codex_session_for_terminal(
+        self, *, terminal_id: str, created_at: float | None
+    ) -> None:
+        """Best-effort: bind a Codex session file to a dashboard terminal (no watcher required)."""
+        terminal_id = (terminal_id or "").strip()
+        if not terminal_id:
+            return
 
-        is_claude_tagged = (w.provider == "claude") or (w.session_type == "claude")
-        return bool(is_claude_tagged and (w.terminal_id or w.context_id))
+        now = time.time()
+        last = self._codex_link_last_attempt.get(terminal_id, 0.0)
+        if now - last < 2.0:
+            return
+        self._codex_link_last_attempt[terminal_id] = now
+
+        try:
+            from ...codex_terminal_linker import read_codex_session_meta
+            from ...db import get_database
+            from ...codex_home import codex_sessions_dir_for_terminal
+        except Exception:
+            return
+
+        try:
+            db = get_database(read_only=False)
+            agent = db.get_agent_by_id(terminal_id)
+            if not agent or agent.provider != "codex" or agent.status != "active":
+                return
+            if agent.session_id:
+                return
+            cwd = (agent.cwd or "").strip()
+            if not cwd:
+                return
+        except Exception:
+            return
+
+        candidates: list[Path] = []
+        sessions_root = codex_sessions_dir_for_terminal(terminal_id)
+        if sessions_root.exists():
+            # Deterministic: isolated per-terminal CODEX_HOME.
+            try:
+                candidates = list(sessions_root.rglob("rollout-*.jsonl"))
+            except Exception:
+                candidates = []
+        else:
+            # Fallback for legacy terminals not launched with isolated CODEX_HOME.
+            try:
+                from ...codex_detector import find_codex_sessions_for_project
+
+                candidates = find_codex_sessions_for_project(Path(cwd), days_back=3)
+            except Exception:
+                candidates = []
+        if not candidates:
+            return
+
+        created_dt: datetime | None = None
+        if created_at is not None:
+            try:
+                created_dt = datetime.fromtimestamp(float(created_at), tz=timezone.utc)
+            except Exception:
+                created_dt = None
+
+        best: Path | None = None
+        best_score: float | None = None
+        candidates.sort(key=lambda p: p.stat().st_mtime if p.exists() else 0, reverse=True)
+        for session_file in candidates[:200]:
+            meta = read_codex_session_meta(session_file)
+            if meta is None or (meta.cwd or "").strip() != cwd:
+                continue
+
+            started_dt: datetime | None = meta.started_at
+            if started_dt is None:
+                try:
+                    started_dt = datetime.fromtimestamp(
+                        session_file.stat().st_mtime, tz=timezone.utc
+                    )
+                except Exception:
+                    started_dt = None
+            if started_dt is None:
+                continue
+
+            if created_dt is not None:
+                delta = abs((started_dt - created_dt).total_seconds())
+            else:
+                try:
+                    delta = abs(time.time() - session_file.stat().st_mtime)
+                except Exception:
+                    continue
+
+            penalty = 0.0
+            origin = (meta.originator or "").lower()
+            if "vscode" in origin:
+                penalty += 3600.0
+            score = float(delta) + penalty
+
+            if best_score is None or score < best_score:
+                best_score = score
+                best = session_file
+
+        if not best:
+            return
+
+        # Avoid binding wildly unrelated sessions.
+        if best_score is not None and best_score > 6 * 60 * 60:
+            return
+
+        try:
+            db.update_agent(
+                terminal_id,
+                provider="codex",
+                session_type="codex",
+                session_id=best.stem,
+                transcript_path=str(best),
+                cwd=cwd,
+                project_dir=cwd,
+                source="dashboard:auto-link",
+            )
+        except Exception:
+            return
 
     def __init__(self, use_native_terminal: bool | None = None) -> None:
         """Initialize the terminal panel.
@@ -420,6 +584,9 @@ class TerminalPanel(Container, can_focus=True):
         self._native_backend: TerminalBackend | None = None
         self._native_backend_checked = False
 
+        # Best-effort Codex session binding without requiring the watcher process.
+        self._codex_link_last_attempt: dict[str, float] = {}
+
     def compose(self) -> ComposeResult:
         logger.debug("TerminalPanel.compose() started")
         try:
@@ -501,10 +668,63 @@ class TerminalPanel(Container, can_focus=True):
 
     async def refresh_data(self) -> None:
         async with self._refresh_lock:
+            t_start = time.time()
+            # Check and close stale terminals if enabled
+            await self._close_stale_terminals_if_enabled()
+            logger.debug(f"[PERF] _close_stale_terminals_if_enabled: {time.time() - t_start:.3f}s")
+
+            t_refresh = time.time()
             if self._is_native_mode():
                 await self._refresh_native_data()
             else:
                 await self._refresh_tmux_data()
+            logger.debug(f"[PERF] total refresh: {time.time() - t_start:.3f}s")
+
+    async def _close_stale_terminals_if_enabled(self) -> None:
+        """Close terminals that haven't been updated for the configured hours."""
+        try:
+            from ...config import ReAlignConfig
+
+            config = ReAlignConfig.load()
+            if not config.auto_close_stale_terminals:
+                return
+
+            stale_hours = config.stale_terminal_hours or 24
+            cutoff_time = datetime.now() - timedelta(hours=stale_hours)
+
+            # Get stale agents from database
+            from ...db import get_database
+
+            db = get_database(read_only=True)
+            all_agents = db.list_agents(status="active", limit=1000)
+
+            stale_agent_ids = set()
+            for agent in all_agents:
+                if agent.updated_at and agent.updated_at < cutoff_time:
+                    stale_agent_ids.add(agent.id)
+
+            if not stale_agent_ids:
+                return
+
+            # Get current windows
+            if self._is_native_mode():
+                backend = await self._ensure_native_backend()
+                if not backend:
+                    return
+                windows = await backend.list_tabs()
+                for w in windows:
+                    if w.terminal_id in stale_agent_ids:
+                        logger.info(f"Auto-closing stale terminal: {w.terminal_id}")
+                        await backend.close_tab(w.session_id)
+            else:
+                windows = tmux_manager.list_inner_windows()
+                for w in windows:
+                    if w.terminal_id in stale_agent_ids:
+                        logger.info(f"Auto-closing stale terminal: {w.terminal_id}")
+                        tmux_manager.kill_inner_window(w.window_id)
+
+        except Exception as e:
+            logger.debug(f"Error checking stale terminals: {e}")
 
     async def _refresh_native_data(self) -> None:
         """Refresh data using native terminal backend."""
@@ -525,24 +745,36 @@ class TerminalPanel(Container, can_focus=True):
             logger.error(f"Failed to list native terminals: {e}")
             return
 
+        # Yield to event loop to keep UI responsive
+        await asyncio.sleep(0)
+
+        # NOTE: _maybe_link_codex_session_for_terminal is intentionally skipped here
+        # because it performs expensive file system scans (find_codex_sessions_for_project)
+        # that can take minutes with many session files. Codex session linking is handled
+        # by the watcher process instead.
+
         active_window_id = next(
             (w.session_id for w in windows if w.active), None
         )
         if self._expanded_window_id and self._expanded_window_id != active_window_id:
             self._expanded_window_id = None
 
-        # Get Claude session IDs for title lookup
+        # Titles (best-effort; native terminals only expose Claude session ids today)
         claude_ids = [
-            w.claude_session_id for w in windows
+            w.claude_session_id
+            for w in windows
             if self._is_claude_window(w) and w.claude_session_id
         ]
         titles = self._fetch_claude_session_titles(claude_ids)
 
+        # Yield to event loop after DB query
+        await asyncio.sleep(0)
+
         # Get context info
         context_info_by_context_id: dict[str, tuple[list[str], int, int]] = {}
         all_context_session_ids: set[str] = set()
         for w in windows:
-            if not self._is_claude_window(w) or not w.context_id:
+            if not self._supports_context(w) or not w.context_id:
                 continue
             session_ids, session_count, event_count = self._get_loaded_context_info(
                 w.context_id
@@ -566,6 +798,7 @@ class TerminalPanel(Container, can_focus=True):
 
     async def _refresh_tmux_data(self) -> None:
         """Refresh data using tmux backend."""
+        t0 = time.time()
         try:
             supported = self.supported()
         except Exception:
@@ -578,20 +811,34 @@ class TerminalPanel(Container, can_focus=True):
             windows = tmux_manager.list_inner_windows()
         except Exception:
             return
+        windows = [w for w in windows if not self._is_internal_tmux_window(w)]
+        logger.debug(f"[PERF] list_inner_windows: {time.time() - t0:.3f}s")
+
+        # Yield to event loop to keep UI responsive
+        await asyncio.sleep(0)
+
+        # NOTE: _maybe_link_codex_session_for_terminal is intentionally skipped here
+        # because it performs expensive file system scans (find_codex_sessions_for_project)
+        # that can take minutes with many session files. Codex session linking is handled
+        # by the watcher process instead.
 
         active_window_id = next((w.window_id for w in windows if w.active), None)
         if self._expanded_window_id and self._expanded_window_id != active_window_id:
             self._expanded_window_id = None
 
-        claude_ids = [
-            w.session_id for w in windows if self._is_claude_window(w) and w.session_id
-        ]
-        titles = self._fetch_claude_session_titles(claude_ids)
+        t1 = time.time()
+        session_ids = [w.session_id for w in windows if self._supports_context(w) and w.session_id]
+        titles = self._fetch_claude_session_titles(session_ids)
+        logger.debug(f"[PERF] fetch_claude_session_titles: {time.time() - t1:.3f}s")
+
+        # Yield to event loop after DB query
+        await asyncio.sleep(0)
 
+        t2 = time.time()
         context_info_by_context_id: dict[str, tuple[list[str], int, int]] = {}
         all_context_session_ids: set[str] = set()
         for w in windows:
-            if not self._is_claude_window(w) or not w.context_id:
+            if not self._supports_context(w) or not w.context_id:
                 continue
             session_ids, session_count, event_count = self._get_loaded_context_info(
                 w.context_id
@@ -604,16 +851,27 @@ class TerminalPanel(Container, can_focus=True):
                 event_count,
             )
             all_context_session_ids.update(session_ids)
+            # Yield periodically during context info gathering
+            await asyncio.sleep(0)
+        logger.debug(f"[PERF] get_loaded_context_info loop: {time.time() - t2:.3f}s")
 
+        t3 = time.time()
         if all_context_session_ids:
             titles.update(self._fetch_claude_session_titles(sorted(all_context_session_ids)))
+        logger.debug(f"[PERF] fetch context session titles: {time.time() - t3:.3f}s")
 
+        t4 = time.time()
         try:
             await self._render_terminals_tmux(windows, titles, context_info_by_context_id)
         except Exception:
             return
+        logger.debug(f"[PERF] render_terminals_tmux: {time.time() - t4:.3f}s")
 
     def _fetch_claude_session_titles(self, session_ids: list[str]) -> dict[str, str]:
+        # Back-compat hook for tests and older call sites.
+        return self._fetch_session_titles(session_ids)
+
+    def _fetch_session_titles(self, session_ids: list[str]) -> dict[str, str]:
         if not session_ids:
             return {}
         try:
@@ -701,7 +959,7 @@ class TerminalPanel(Container, can_focus=True):
             loaded_ids: list[str] = []
             raw_sessions = 0
             raw_events = 0
-            if self._is_claude_window(w) and w.context_id:
+            if self._supports_context(w) and w.context_id:
                 loaded_ids, raw_sessions, raw_events = context_info_by_context_id.get(
                     w.context_id, ([], 0, 0)
                 )
@@ -716,9 +974,7 @@ class TerminalPanel(Container, can_focus=True):
                 )
             )
 
-            can_toggle_ctx = bool(
-                self._is_claude_window(w) and w.context_id and (raw_sessions or raw_events)
-            )
+            can_toggle_ctx = bool(self._supports_context(w) and w.context_id and (raw_sessions or raw_events))
             expanded = bool(w.active and w.session_id == self._expanded_window_id)
             if w.active and can_toggle_ctx:
                 await row.mount(
@@ -741,7 +997,7 @@ class TerminalPanel(Container, can_focus=True):
                 )
             )
 
-            if w.active and self._is_claude_window(w) and w.context_id and expanded:
+            if w.active and self._supports_context(w) and w.context_id and expanded:
                 ctx = VerticalScroll(id=f"ctx-{safe}", classes="context-sessions")
                 await container.mount(ctx)
                 if loaded_ids:
@@ -790,7 +1046,7 @@ class TerminalPanel(Container, can_focus=True):
             loaded_ids: list[str] = []
             raw_sessions = 0
             raw_events = 0
-            if self._is_claude_window(w) and w.context_id:
+            if self._supports_context(w) and w.context_id:
                 loaded_ids, raw_sessions, raw_events = context_info_by_context_id.get(
                     w.context_id, ([], 0, 0)
                 )
@@ -803,9 +1059,7 @@ class TerminalPanel(Container, can_focus=True):
                     classes=switch_classes,
                 )
             )
-            can_toggle_ctx = bool(
-                self._is_claude_window(w) and w.context_id and (raw_sessions or raw_events)
-            )
+            can_toggle_ctx = bool(self._supports_context(w) and w.context_id and (raw_sessions or raw_events))
             expanded = bool(w.active and w.window_id == self._expanded_window_id)
             if w.active and can_toggle_ctx:
                 await row.mount(
@@ -827,7 +1081,7 @@ class TerminalPanel(Container, can_focus=True):
                 )
             )
 
-            if w.active and self._is_claude_window(w) and w.context_id and expanded:
+            if w.active and self._supports_context(w) and w.context_id and expanded:
                 ctx = VerticalScroll(id=f"ctx-{safe}", classes="context-sessions")
                 await container.mount(ctx)
                 if loaded_ids:
@@ -868,9 +1122,26 @@ class TerminalPanel(Container, can_focus=True):
         raw_events: int = 0,
     ) -> str | Text:
         """Generate label for native terminal window."""
-        if not self._is_claude_window(w):
+        if not self._supports_context(w):
             return Text(w.name, no_wrap=True, overflow="ellipsis")
 
+        if self._is_codex_window(w):
+            details = Text(no_wrap=True, overflow="ellipsis")
+            details.append("Codex")
+            details.append("\n")
+            detail_line = "[Codex]"
+            if w.active:
+                loaded_count = raw_sessions + raw_events
+                detail_line = f"{detail_line} | loaded context: {loaded_count}"
+            else:
+                detail_line = (
+                    f"{detail_line} · {self._format_context_summary(raw_sessions, raw_events)}"
+                )
+            if w.metadata.get("no_track") == "1":
+                detail_line = f"{detail_line} [NT]"
+            details.append(detail_line, style="dim not bold")
+            return details
+
         title = titles.get(w.claude_session_id or "", "").strip() if w.claude_session_id else ""
         header = title or ("Claude" if w.claude_session_id else "New Claude")
 
@@ -902,9 +1173,32 @@ class TerminalPanel(Container, can_focus=True):
         raw_events: int = 0,
     ) -> str | Text:
         """Generate label for tmux window."""
-        if not self._is_claude_window(w):
+        if not self._supports_context(w):
             return Text(w.window_name, no_wrap=True, overflow="ellipsis")
 
+        if self._is_codex_window(w):
+            title = titles.get(w.session_id or "", "").strip() if w.session_id else ""
+            header = title or ("Codex" if w.session_id else "New Codex")
+
+            details = Text(no_wrap=True, overflow="ellipsis")
+            details.append(header)
+            details.append("\n")
+
+            detail_line = "[Codex]"
+            if w.session_id:
+                detail_line = f"{detail_line} #{self._short_id(w.session_id)}"
+            if w.active:
+                loaded_count = raw_sessions + raw_events
+                detail_line = f"{detail_line} | loaded context: {loaded_count}"
+            else:
+                detail_line = (
+                    f"{detail_line} · {self._format_context_summary(raw_sessions, raw_events)}"
+                )
+            if w.no_track:
+                detail_line = f"{detail_line} [NT]"
+            details.append(detail_line, style="dim not bold")
+            return details
+
         title = titles.get(w.session_id or "", "").strip() if w.session_id else ""
         header = title or ("Claude" if w.session_id else "New Claude")
 
@@ -956,13 +1250,23 @@ class TerminalPanel(Container, can_focus=True):
             return
 
         agent_type, workspace, skip_permissions, no_track = result
-        self.run_worker(
-            self._create_agent(
-                agent_type, workspace, skip_permissions=skip_permissions, no_track=no_track
-            ),
-            group="terminal-panel-create",
-            exclusive=True,
-        )
+
+        # Capture self reference for use in the deferred callback
+        panel = self
+
+        # Use app.call_later to defer worker creation until after the modal is dismissed.
+        # This ensures the modal screen is fully closed before the worker starts,
+        # preventing UI update conflicts between modal closing and terminal panel refresh.
+        def start_worker() -> None:
+            panel.run_worker(
+                panel._create_agent(
+                    agent_type, workspace, skip_permissions=skip_permissions, no_track=no_track
+                ),
+                group="terminal-panel-create",
+                exclusive=True,
+            )
+
+        self.app.call_later(start_worker)
 
     async def _create_agent(
         self, agent_type: str, workspace: str, *, skip_permissions: bool = False, no_track: bool = False
@@ -971,12 +1275,19 @@ class TerminalPanel(Container, can_focus=True):
         if agent_type == "claude":
             await self._create_claude_terminal(workspace, skip_permissions=skip_permissions, no_track=no_track)
         elif agent_type == "codex":
-            await self._create_codex_terminal(workspace)
+            await self._create_codex_terminal(workspace, no_track=no_track)
         elif agent_type == "opencode":
             await self._create_opencode_terminal(workspace)
         elif agent_type == "zsh":
             await self._create_zsh_terminal(workspace)
-        await self.refresh_data()
+        # Schedule refresh in a separate worker to avoid blocking UI.
+        # The refresh involves slow synchronous operations (DB queries, file scans)
+        # that would otherwise freeze the dashboard.
+        self.run_worker(
+            self.refresh_data(),
+            group="terminal-panel-refresh",
+            exclusive=True,
+        )
 
     async def _create_claude_terminal(
         self, workspace: str, *, skip_permissions: bool = False, no_track: bool = False
@@ -1064,6 +1375,7 @@ class TerminalPanel(Container, can_focus=True):
             terminal_id=terminal_id,
             provider="claude",
             context_id=context_id,
+            no_track=no_track,
         )
         if not created:
             self.app.notify("Failed to open Claude terminal", title="Terminal", severity="error")
@@ -1119,16 +1431,54 @@ class TerminalPanel(Container, can_focus=True):
         except Exception:
             pass
 
-    async def _create_codex_terminal(self, workspace: str) -> None:
+    async def _create_codex_terminal(self, workspace: str, *, no_track: bool = False) -> None:
         """Create a new Codex terminal."""
+        terminal_id = tmux_manager.new_terminal_id()
+        context_id = tmux_manager.new_context_id("cx")
+
+        # Use per-terminal CODEX_HOME so sessions/config are isolated and binding is deterministic.
+        try:
+            from ...codex_home import prepare_codex_home
+
+            codex_home = prepare_codex_home(terminal_id)
+        except Exception:
+            codex_home = None
+
+        env = {
+            tmux_manager.ENV_TERMINAL_ID: terminal_id,
+            tmux_manager.ENV_TERMINAL_PROVIDER: "codex",
+            tmux_manager.ENV_CONTEXT_ID: context_id,
+        }
+        if codex_home is not None:
+            env["CODEX_HOME"] = str(codex_home)
+        if no_track:
+            env["ALINE_NO_TRACK"] = "1"
+
+        # Persist agent early so the watcher can bind the Codex session file back to this terminal.
+        try:
+            from ...db import get_database
+
+            db = get_database(read_only=False)
+            db.get_or_create_agent(
+                terminal_id,
+                provider="codex",
+                session_type="codex",
+                context_id=context_id,
+                cwd=workspace,
+                project_dir=workspace,
+                source="dashboard",
+            )
+        except Exception:
+            pass
+
         if self._is_native_mode():
             backend = await self._ensure_native_backend()
             if backend:
-                terminal_id = tmux_manager.new_terminal_id()
                 session_id = await backend.create_tab(
                     command="codex",
                     terminal_id=terminal_id,
                     name="Codex",
+                    env=env,
                     cwd=workspace,
                 )
                 if not session_id:
@@ -1141,7 +1491,14 @@ class TerminalPanel(Container, can_focus=True):
         command = self._command_in_directory(
             tmux_manager.zsh_run_and_keep_open("codex"), workspace
         )
-        created = tmux_manager.create_inner_window("codex", command)
+        created = tmux_manager.create_inner_window(
+            "codex",
+            tmux_manager.shell_command_with_env(command, env),
+            terminal_id=terminal_id,
+            provider="codex",
+            context_id=context_id,
+            no_track=no_track,
+        )
         if not created:
             self.app.notify("Failed to open Codex terminal", title="Terminal", severity="error")
 
@@ -1173,6 +1530,8 @@ class TerminalPanel(Container, can_focus=True):
 
     async def _create_zsh_terminal(self, workspace: str) -> None:
         """Create a new zsh terminal."""
+        t0 = time.time()
+        logger.info(f"[PERF] _create_zsh_terminal START")
         if self._is_native_mode():
             backend = await self._ensure_native_backend()
             if backend:
@@ -1187,13 +1546,19 @@ class TerminalPanel(Container, can_focus=True):
                     self.app.notify(
                         "Failed to open zsh terminal", title="Terminal", severity="error"
                     )
+                logger.info(f"[PERF] _create_zsh_terminal native END: {time.time() - t0:.3f}s")
                 return
 
         # Tmux fallback
+        t1 = time.time()
         command = self._command_in_directory("zsh", workspace)
+        logger.info(f"[PERF] _create_zsh_terminal command ready: {time.time() - t1:.3f}s")
+        t2 = time.time()
         created = tmux_manager.create_inner_window("zsh", command)
+        logger.info(f"[PERF] _create_zsh_terminal create_inner_window: {time.time() - t2:.3f}s")
         if not created:
             self.app.notify("Failed to open zsh terminal", title="Terminal", severity="error")
+        logger.info(f"[PERF] _create_zsh_terminal TOTAL: {time.time() - t0:.3f}s")
 
     async def on_button_pressed(self, event: Button.Pressed) -> None:
         button_id = event.button.id or ""