aline-ai 0.6.2__py3-none-any.whl → 0.6.4__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
+
+        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
 
-        is_claude_tagged = (w.provider == "claude") or (w.session_type == "claude")
-        return bool(is_claude_tagged and (w.terminal_id or w.context_id))
+                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,11 +668,60 @@ class TerminalPanel(Container, can_focus=True):
 
     async def refresh_data(self) -> None:
         async with self._refresh_lock:
+            # Check and close stale terminals if enabled
+            await self._close_stale_terminals_if_enabled()
+
             if self._is_native_mode():
                 await self._refresh_native_data()
             else:
                 await self._refresh_tmux_data()
 
+    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."""
         backend = await self._ensure_native_backend()
@@ -525,15 +741,26 @@ class TerminalPanel(Container, can_focus=True):
             logger.error(f"Failed to list native terminals: {e}")
             return
 
+        # Best-effort: bind Codex session ids for native terminals (no watcher required).
+        try:
+            for w in windows:
+                if self._is_codex_window(w) and w.terminal_id:
+                    self._maybe_link_codex_session_for_terminal(
+                        terminal_id=w.terminal_id, created_at=w.created_at
+                    )
+        except Exception:
+            pass
+
         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)
@@ -542,7 +769,7 @@ class TerminalPanel(Container, can_focus=True):
         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
@@ -578,20 +805,29 @@ 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)]
+
+        # Best-effort: bind Codex session ids for tmux terminals (no watcher required).
+        try:
+            for w in windows:
+                if self._is_codex_window(w) and not w.session_id and w.terminal_id:
+                    self._maybe_link_codex_session_for_terminal(
+                        terminal_id=w.terminal_id, created_at=w.created_at
+                    )
+        except Exception:
+            pass
 
         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)
+        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)
 
         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
@@ -614,6 +850,10 @@ class TerminalPanel(Container, can_focus=True):
             return
 
     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 +941,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 +956,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 +979,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 +1028,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 +1041,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 +1063,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 +1104,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 +1155,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")
 
@@ -971,7 +1247,7 @@ 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":
@@ -1064,6 +1340,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 +1396,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 +1456,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")
 

realign/dashboard/widgets/watcher_panel.py

@@ -318,7 +318,6 @@ class WatcherPanel(Container, can_focus=True):
                 ("Claude", "~/.claude/projects/", config.auto_detect_claude),
                 ("Codex", "~/.codex/sessions/", config.auto_detect_codex),
                 ("Gemini", "~/.gemini/tmp/", config.auto_detect_gemini),
-                ("Antigravity", "~/.gemini/antigravity/brain/", config.auto_detect_antigravity),
             ]
         except Exception:
             monitored_paths = []
@@ -426,7 +425,6 @@ class WatcherPanel(Container, can_focus=True):
                     "claude": "Claude",
                     "codex": "Codex",
                     "gemini": "Gemini",
-                    "antigravity": "Antigravity",
                 }
                 source = source_map.get(session_type, session_type)
                 project = Path(workspace).name if workspace else "-"

realign/db/sqlite_db.py

@@ -999,8 +999,7 @@ class SQLiteDatabase(DatabaseInterface):
         # - If the caller requested regeneration (`skip_dedup=True`), we must allow requeue.
         # - If the DB is missing the corresponding turn row (historical bug / manual DB edits),
         #   requeue so the system can self-heal instead of getting stuck in a "done but missing" state.
-        # - For antigravity, turns may update-in-place, so allow requeue even if done.
-        requeue_done = bool(skip_dedup) or (session_type or "").lower() in ("antigravity",)
+        requeue_done = bool(skip_dedup)
         try:
             conn = self._get_connection()
             row = conn.execute(
@@ -1463,6 +1462,82 @@ class SQLiteDatabase(DatabaseInterface):
         except Exception:
             return 0
 
+    def requeue_failed_jobs(
+        self,
+        *,
+        kinds: Optional[List[str]] = None,
+    ) -> Tuple[int, List[Dict[str, Any]]]:
+        """
+        Requeue all failed jobs, optionally filtering by kind.
+
+        Returns:
+            (count, jobs) - number of jobs requeued and their details
+        """
+        conn = self._get_connection()
+        try:
+            # First, get the failed jobs
+            where_clauses: list[str] = ["status = 'failed'"]
+            params: list[Any] = []
+            if kinds:
+                placeholders = ",".join(["?"] * len(kinds))
+                where_clauses.append(f"kind IN ({placeholders})")
+                params.extend(kinds)
+
+            where_sql = "WHERE " + " AND ".join(where_clauses)
+
+            rows = conn.execute(
+                f"""
+                SELECT id, kind, dedupe_key, payload, last_error, attempts
+                FROM jobs
+                {where_sql}
+                ORDER BY updated_at DESC
+                """,
+                tuple(params),
+            ).fetchall()
+
+            if not rows:
+                return 0, []
+
+            jobs_info: List[Dict[str, Any]] = []
+            for row in rows:
+                payload_raw = row["payload"] or "{}"
+                try:
+                    payload_obj = json.loads(payload_raw)
+                except Exception:
+                    payload_obj = {}
+                jobs_info.append({
+                    "id": str(row["id"]),
+                    "kind": row["kind"],
+                    "dedupe_key": row["dedupe_key"],
+                    "payload": payload_obj,
+                    "last_error": row["last_error"],
+                    "attempts": row["attempts"],
+                })
+
+            # Requeue them
+            conn.execute(
+                f"""
+                UPDATE jobs
+                SET status = 'queued',
+                    attempts = 0,
+                    next_run_at = datetime('now'),
+                    last_error = NULL,
+                    locked_until = NULL,
+                    locked_by = NULL,
+                    updated_at = datetime('now')
+                {where_sql}
+                """,
+                tuple(params),
+            )
+            conn.commit()
+
+            return len(jobs_info), jobs_info
+        except sqlite3.OperationalError:
+            return 0, []
+        except Exception:
+            conn.rollback()
+            return 0, []
+
     def update_turn_summary(
         self,
         turn_id: str,