aline-ai 0.7.3__py3-none-any.whl → 0.7.4__py3-none-any.whl

realign/config.py

@@ -19,7 +19,7 @@ class ReAlignConfig:
     llm_provider: str = "auto"  # LLM provider: "auto", "claude", or "openai"
     auto_detect_claude: bool = True  # Enable Claude Code session auto-detection
     auto_detect_codex: bool = True  # Enable Codex session auto-detection
-    auto_detect_gemini: bool = True  # Enable Gemini CLI session auto-detection
+    auto_detect_gemini: bool = False  # Enable Gemini CLI session auto-detection (disabled by default)
     mcp_auto_commit: bool = True  # Enable watcher auto-commit after each user request completes
     enable_temp_turn_titles: bool = True  # Generate temporary turn titles on user prompt submit
     share_backend_url: str = (
@@ -36,10 +36,6 @@ class ReAlignConfig:
     # Local API server port (for one-click browser import)
     local_api_port: int = 17280
 
-    # Terminal auto-close settings
-    auto_close_stale_terminals: bool = False  # Auto-close terminals inactive for 24+ hours
-    stale_terminal_hours: int = 24  # Hours of inactivity before auto-closing
-
     @classmethod
     def load(cls, config_path: Optional[Path] = None) -> "ReAlignConfig":
         """Load configuration from file with environment variable overrides."""
@@ -89,13 +85,11 @@ class ReAlignConfig:
             "uid": os.getenv("REALIGN_UID"),
             "max_catchup_sessions": os.getenv("REALIGN_MAX_CATCHUP_SESSIONS"),
             "local_api_port": os.getenv("ALINE_LOCAL_API_PORT"),
-            "auto_close_stale_terminals": os.getenv("REALIGN_AUTO_CLOSE_STALE_TERMINALS"),
-            "stale_terminal_hours": os.getenv("REALIGN_STALE_TERMINAL_HOURS"),
         }
 
         for key, value in env_overrides.items():
             if value is not None:
-                if key in ["summary_max_chars", "max_catchup_sessions", "stale_terminal_hours", "local_api_port"]:
+                if key in ["summary_max_chars", "max_catchup_sessions", "local_api_port"]:
                     config_dict[key] = int(value)
                 elif key in [
                     "redact_on_match",
@@ -105,7 +99,6 @@ class ReAlignConfig:
                     "auto_detect_gemini",
                     "mcp_auto_commit",
                     "enable_temp_turn_titles",
-                    "auto_close_stale_terminals",
                 ]:
                     config_dict[key] = value.lower() in ("true", "1", "yes")
                 else:
@@ -144,8 +137,6 @@ class ReAlignConfig:
             "uid": self.uid,
             "max_catchup_sessions": self.max_catchup_sessions,
             "local_api_port": self.local_api_port,
-            "auto_close_stale_terminals": self.auto_close_stale_terminals,
-            "stale_terminal_hours": self.stale_terminal_hours,
         }
 
         with open(config_path, "w", encoding="utf-8") as f:
@@ -182,6 +173,7 @@ use_LLM: true                    # Whether to use a cloud LLM to generate summar
 llm_provider: "auto"             # LLM provider: "auto" (try Claude then OpenAI), "claude", or "openai"
 auto_detect_claude: true         # Automatically detect Claude Code session directory (~/.claude/projects/)
 auto_detect_codex: true          # Automatically detect Codex session files (~/.codex/sessions/)
+auto_detect_gemini: false        # Gemini auto-detect is disabled by default
 mcp_auto_commit: true            # Enable watcher to auto-commit after each user request completes
 enable_temp_turn_titles: true    # Generate temporary turn titles on user prompt submit
 share_backend_url: "https://realign-server.vercel.app"  # Backend URL for interactive share export

realign/dashboard/app.py

@@ -1,14 +1,17 @@
 """Aline Dashboard - Main Application."""
 
+import asyncio
 import os
 import time
 import traceback
 
 from textual.app import App, ComposeResult
 from textual.binding import Binding
+from textual.worker import Worker, WorkerState
 from textual.widgets import Footer, TabbedContent, TabPane
 
 from ..logging_config import setup_logger
+from .diagnostics import DashboardDiagnostics
 from .widgets import (
     AlineHeader,
     ConfigPanel,
@@ -40,6 +43,7 @@ class AlineDashboard(App):
         Binding("?", "help", "Help"),
         Binding("tab", "next_tab", "Next Tab", priority=True, show=False),
         Binding("shift+tab", "prev_tab", "Prev Tab", priority=True, show=False),
+        Binding("ctrl+d", "dump_diagnostics", "Dump Diagnostics", show=False),
         Binding("ctrl+c", "quit_confirm", "Quit", priority=True),
     ]
 
@@ -57,7 +61,15 @@ class AlineDashboard(App):
         self.use_native_terminal = use_native_terminal
         self._native_terminal_mode = self._detect_native_mode()
         self._local_api_server = None
+        self._diagnostics = DashboardDiagnostics.start()
+        self._tmux_width_timer = None
+        self._diagnostics.install_global_exception_hooks()
+        self._watchdog_timer = None
         self._apply_saved_theme()
+        self._diagnostics.event(
+            "dashboard_init",
+            native_terminal=bool(self._native_terminal_mode),
+        )
         logger.info(f"AlineDashboard initialized (native_terminal={self._native_terminal_mode})")
 
     def _detect_native_mode(self) -> bool:
@@ -92,6 +104,11 @@ class AlineDashboard(App):
         logger.info("on_mount() started")
         try:
             self._quit_confirm_deadline: float | None = None
+            try:
+                loop = asyncio.get_running_loop()
+                self._diagnostics.install_asyncio_exception_handler(loop)
+            except Exception:
+                pass
 
             # Start local API server for one-click browser import
             self._start_local_api_server()
@@ -100,11 +117,129 @@ class AlineDashboard(App):
             if self._native_terminal_mode:
                 self._setup_native_terminal_layout()
 
+            # Watchdog: capture snapshots for intermittent blank/stuck UI issues.
+            if self._watchdog_timer is None:
+                self._watchdog_timer = self.set_interval(5.0, self._watchdog_check)
+
             logger.info("on_mount() completed successfully")
         except Exception as e:
             logger.error(f"on_mount() failed: {e}\n{traceback.format_exc()}")
             raise
 
+    def on_resize(self) -> None:
+        """Keep the tmux outer layout stable when the terminal is resized."""
+        if self._native_terminal_mode:
+            return
+
+        # Debounce: terminal resize can generate many events; keep the UI responsive.
+        try:
+            if self._tmux_width_timer is not None:
+                try:
+                    self._tmux_width_timer.stop()
+                except Exception:
+                    pass
+            self._tmux_width_timer = self.set_timer(0.05, self._enforce_tmux_dashboard_width)
+        except Exception:
+            return
+
+    def _enforce_tmux_dashboard_width(self) -> None:
+        try:
+            from . import tmux_manager
+
+            tmux_manager.enforce_outer_dashboard_pane_width()
+        except Exception:
+            return
+
+    def on_unmount(self) -> None:
+        try:
+            self._diagnostics.event("dashboard_unmount")
+        except Exception:
+            pass
+
+    def on_worker_state_changed(self, event: Worker.StateChanged) -> None:
+        if event.state != WorkerState.ERROR:
+            return
+        try:
+            worker = event.worker
+            err = getattr(worker, "error", None)
+            if isinstance(err, BaseException):
+                self._diagnostics.exception(
+                    "worker_error",
+                    err,
+                    worker_name=str(getattr(worker, "name", "") or ""),
+                    worker_group=str(getattr(worker, "group", "") or ""),
+                    worker_state=str(event.state),
+                )
+            else:
+                self._diagnostics.event(
+                    "worker_error",
+                    error=str(err),
+                    worker_name=str(getattr(worker, "name", "") or ""),
+                    worker_group=str(getattr(worker, "group", "") or ""),
+                    worker_state=str(event.state),
+                )
+        except Exception:
+            return
+
+    def _watchdog_check(self) -> None:
+        """Lightweight watchdog to detect UI blanking and missing panes."""
+        try:
+            panel = self.query_one(AgentsPanel)
+            state = panel.diagnostics_state()
+            agents_count = int(state.get("agents_count", 0) or 0)
+            children = int(state.get("agents_list_children", 1) or 0)
+            if agents_count > 0 and children == 0:
+                self._diagnostics.snapshot(reason="agents_panel_blank", app=self, agents_panel=state)
+                panel.force_render(reason="watchdog_blank")
+        except Exception:
+            pass
+
+        # Only relevant for tmux mode.
+        if self._native_terminal_mode:
+            return
+        try:
+            from . import tmux_manager
+
+            panes = tmux_manager.list_outer_panes(timeout_s=0.2)
+            if panes and len(panes) < 2:
+                try:
+                    tmux_state = tmux_manager.collect_tmux_debug_state()
+                except Exception:
+                    tmux_state = {}
+                self._diagnostics.snapshot(
+                    reason="tmux_outer_missing_right_pane",
+                    app=self,
+                    tmux_state=tmux_state,
+                )
+                try:
+                    tmux_manager.ensure_right_pane_ready()
+                except Exception:
+                    pass
+            else:
+                pane1_cmd = ""
+                for ln in panes:
+                    parts = ln.split("\t")
+                    if parts and parts[0] == "1":
+                        pane1_cmd = parts[2] if len(parts) > 2 else ""
+                        break
+                if pane1_cmd and pane1_cmd != "tmux":
+                    try:
+                        tmux_state = tmux_manager.collect_tmux_debug_state()
+                    except Exception:
+                        tmux_state = {}
+                    self._diagnostics.snapshot(
+                        reason="tmux_right_pane_not_attached",
+                        app=self,
+                        pane1_current_command=pane1_cmd,
+                        tmux_state=tmux_state,
+                    )
+                    try:
+                        tmux_manager.ensure_right_pane_ready()
+                    except Exception:
+                        pass
+        except Exception:
+            pass
+
     def _start_local_api_server(self) -> None:
         """Start the local HTTP API server for browser-based agent import."""
         try:
@@ -177,6 +312,10 @@ class AlineDashboard(App):
 
     async def action_refresh(self) -> None:
         """Refresh the current tab."""
+        try:
+            self._diagnostics.event("action_refresh")
+        except Exception:
+            pass
         tabbed_content = self.query_one(TabbedContent)
         active_tab_id = tabbed_content.active
 
@@ -191,6 +330,17 @@ class AlineDashboard(App):
 
         self.push_screen(HelpScreen())
 
+    def action_dump_diagnostics(self) -> None:
+        try:
+            self._diagnostics.snapshot(reason="manual_dump", app=self)
+            path = self._diagnostics.path
+            if path:
+                self.notify(f"Diagnostics written: {path}", title="Diagnostics", timeout=4)
+            else:
+                self.notify("Diagnostics written to stderr (no log dir)", title="Diagnostics", timeout=4)
+        except Exception as e:
+            self.notify(f"Diagnostics failed: {e}", title="Diagnostics", severity="error", timeout=4)
+
     def action_quit_confirm(self) -> None:
         """Quit only when Ctrl+C is pressed twice quickly."""
         now = _monotonic()

realign/dashboard/diagnostics.py

@@ -0,0 +1,274 @@
+"""Dashboard diagnostics and high-signal logging.
+
+This module is intentionally best-effort: diagnostics should never crash the dashboard.
+It provides a JSONL log (one JSON object per line) with correlation IDs and state
+snapshots for debugging intermittent UI issues (blank panes, stuck refreshes, etc.).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import platform
+import sys
+import threading
+import time
+import traceback
+import uuid
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from ..logging_config import get_log_directory
+
+
+def _safe_json(obj: Any) -> str:
+    return json.dumps(obj, ensure_ascii=False, default=str, separators=(",", ":"))
+
+
+def _now_iso() -> str:
+    return datetime.now().isoformat(timespec="seconds")
+
+
+def _selected_env() -> dict[str, str]:
+    allow_prefixes = ("ALINE_", "REALIGN_")
+    allow_keys = {
+        "TERM",
+        "TERM_PROGRAM",
+        "TERM_PROGRAM_VERSION",
+        "TMUX",
+        "SHELL",
+        "LANG",
+        "LC_ALL",
+    }
+    out: dict[str, str] = {}
+    for k, v in os.environ.items():
+        if any(k.startswith(p) for p in allow_prefixes) or k in allow_keys:
+            out[k] = str(v)
+    return out
+
+
+_DIAG_SINGLETON: "DashboardDiagnostics | None" = None
+
+
+def reset_dashboard_diagnostics_for_tests() -> None:
+    """Reset the diagnostics singleton/handlers (intended for pytest)."""
+    global _DIAG_SINGLETON
+    _DIAG_SINGLETON = None
+    logger = logging.getLogger("realign.dashboard.diagnostics")
+    for h in list(logger.handlers):
+        try:
+            logger.removeHandler(h)
+        except Exception:
+            pass
+        try:
+            h.close()
+        except Exception:
+            pass
+
+
+@dataclass(frozen=True)
+class DashboardDiagnostics:
+    session_id: str
+    path: Path | None
+    logger: logging.Logger
+
+    @classmethod
+    def start(cls) -> "DashboardDiagnostics":
+        """Create a per-run diagnostics logger (never raises)."""
+        global _DIAG_SINGLETON
+        if _DIAG_SINGLETON is not None:
+            return _DIAG_SINGLETON
+
+        session_id = uuid.uuid4().hex[:12]
+
+        logger = logging.getLogger("realign.dashboard.diagnostics")
+        logger.setLevel(logging.DEBUG)
+        logger.propagate = False
+
+        # Avoid duplicating handlers across hot reloads / repeated imports.
+        if logger.handlers:
+            diag = cls(session_id=session_id, path=None, logger=logger)
+            _DIAG_SINGLETON = diag
+            return diag
+
+        path: Path | None = None
+        handler: logging.Handler | None = None
+
+        try:
+            root = get_log_directory()
+            diag_dir = root / "dashboard_diagnostics"
+            diag_dir.mkdir(parents=True, exist_ok=True)
+            stamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            path = diag_dir / f"dashboard_{stamp}_pid{os.getpid()}_{session_id}.jsonl"
+            handler = logging.FileHandler(path, encoding="utf-8")
+        except Exception:
+            # Fall back to stderr; still better than losing all diagnostics.
+            handler = logging.StreamHandler()
+            path = None
+
+        handler.setLevel(logging.DEBUG)
+        handler.setFormatter(logging.Formatter(fmt="%(message)s"))
+        logger.addHandler(handler)
+
+        diag = cls(session_id=session_id, path=path, logger=logger)
+        _DIAG_SINGLETON = diag
+        diag.event(
+            "dashboard_diagnostics_started",
+            pid=os.getpid(),
+            python=sys.version.split()[0],
+            platform=platform.platform(),
+            env=_selected_env(),
+        )
+        return diag
+
+    def event(self, name: str, **fields: Any) -> None:
+        payload = {
+            "ts": _now_iso(),
+            "t_monotonic": round(time.monotonic(), 6),
+            "pid": os.getpid(),
+            "thread": threading.current_thread().name,
+            "session_id": self.session_id,
+            "event": name,
+            **fields,
+        }
+        try:
+            self.logger.info(_safe_json(payload))
+        except Exception:
+            # Diagnostics must never crash the app.
+            return
+
+    def exception(self, name: str, exc: BaseException, **fields: Any) -> None:
+        try:
+            tb = "".join(traceback.format_exception(type(exc), exc, exc.__traceback__))
+        except Exception:
+            tb = ""
+        self.event(
+            name,
+            error_type=type(exc).__name__,
+            error=str(exc),
+            traceback=tb,
+            **fields,
+        )
+
+    def snapshot(self, *, reason: str, app: Any | None = None, **fields: Any) -> None:  # noqa: ANN401
+        """Capture a lightweight state snapshot (best-effort)."""
+        snap: dict[str, Any] = {
+            "reason": reason,
+            "fields": fields,
+        }
+
+        if app is not None:
+            snap["app"] = _snapshot_textual_app(app)
+
+        try:
+            from . import tmux_manager
+
+            snap["tmux"] = tmux_manager.collect_tmux_debug_state()
+        except Exception:
+            pass
+
+        self.event("dashboard_snapshot", **snap)
+
+    def install_global_exception_hooks(self) -> None:
+        """Install sys/threading exception hooks (best-effort)."""
+        try:
+            orig_sys_hook = sys.excepthook
+
+            def sys_hook(exc_type, exc, tb):  # type: ignore[no-untyped-def]
+                try:
+                    self.exception(
+                        "unhandled_exception",
+                        exc if isinstance(exc, BaseException) else Exception(str(exc)),
+                        where="sys.excepthook",
+                    )
+                except Exception:
+                    pass
+                try:
+                    orig_sys_hook(exc_type, exc, tb)
+                except Exception:
+                    pass
+
+            sys.excepthook = sys_hook
+        except Exception:
+            pass
+
+        try:
+            orig_thread_hook = threading.excepthook
+
+            def thread_hook(args):  # type: ignore[no-untyped-def]
+                try:
+                    self.exception(
+                        "unhandled_exception",
+                        args.exc_value,
+                        where="threading.excepthook",
+                        thread=str(getattr(args, "thread", None)),
+                    )
+                except Exception:
+                    pass
+                try:
+                    orig_thread_hook(args)
+                except Exception:
+                    pass
+
+            threading.excepthook = thread_hook
+        except Exception:
+            pass
+
+    def install_asyncio_exception_handler(self, loop: asyncio.AbstractEventLoop) -> None:
+        """Install an asyncio loop exception handler (best-effort)."""
+
+        def handler(loop: asyncio.AbstractEventLoop, context: dict[str, Any]) -> None:
+            exc = context.get("exception")
+            if isinstance(exc, BaseException):
+                self.exception(
+                    "asyncio_exception",
+                    exc,
+                    message=str(context.get("message") or ""),
+                    context={k: v for k, v in context.items() if k not in {"exception"}},
+                )
+                return
+            self.event(
+                "asyncio_exception",
+                message=str(context.get("message") or ""),
+                context={k: v for k, v in context.items()},
+            )
+
+        try:
+            loop.set_exception_handler(handler)
+        except Exception:
+            return
+
+
+def _snapshot_textual_app(app: Any) -> dict[str, Any]:  # noqa: ANN401
+    snap: dict[str, Any] = {}
+
+    try:
+        snap["title"] = str(getattr(app, "TITLE", "") or "")
+        snap["screen"] = type(getattr(app, "screen", None)).__name__
+        snap["dark"] = bool(getattr(app, "dark", False))
+        snap["theme"] = str(getattr(app, "theme", "") or "")
+    except Exception:
+        pass
+
+    # Best-effort widget checks for known failure modes.
+    try:
+        from textual.widgets import TabbedContent  # imported lazily
+
+        tabbed = app.query_one(TabbedContent)
+        snap["active_tab"] = str(getattr(tabbed, "active", "") or "")
+    except Exception:
+        pass
+
+    try:
+        from textual.containers import Vertical
+
+        agents_list = app.query_one("#agents-list", Vertical)
+        snap["agents_list_children"] = int(len(getattr(agents_list, "children", []) or []))
+    except Exception:
+        pass
+
+    return snap

realign/dashboard/screens/create_agent.py

@@ -99,7 +99,8 @@ class CreateAgentScreen(ModalScreen[Optional[tuple[str, str, bool, bool]]]):
     }
 
     CreateAgentScreen #create-agent-root {
-        width: 60;
+        width: 100%;
+        max-width: 60;
         height: auto;
         max-height: 80%;
         padding: 1 2;