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

realign/dashboard/tmux_manager.py

@@ -14,6 +14,7 @@ import shutil
 import stat
 import subprocess
 import sys
+import threading
 import time
 import traceback
 import uuid
@@ -47,6 +48,10 @@ OPT_ATTENTION = "@aline_attention"
 OPT_CREATED_AT = "@aline_created_at"
 OPT_NO_TRACK = "@aline_no_track"
 
+# Default outer layout preferences (tmux mode).
+# Note: tmux "pixels" are terminal cell columns; Textual has no notion of pixels.
+DEFAULT_DASHBOARD_PANE_WIDTH_COLS = 45
+
 
 @dataclass(frozen=True)
 class InnerWindow:
@@ -62,6 +67,9 @@ class InnerWindow:
     attention: str | None = None  # "permission_request", "stop", or None
     created_at: float | None = None  # Unix timestamp when window was created
     no_track: bool = False  # Whether tracking is disabled for this terminal
+    pane_pid: int | None = None  # PID of the initial process in the pane
+    pane_current_command: str | None = None  # Foreground process in the pane
+    pane_tty: str | None = None  # Controlling TTY for processes in the pane
 
 
 def tmux_available() -> bool:
@@ -93,26 +101,31 @@ def tmux_version() -> tuple[int, int] | None:
     return int(match.group(1)), int(match.group(2))
 
 
-def _run_tmux(args: Sequence[str], *, capture: bool = False) -> subprocess.CompletedProcess[str]:
-    return subprocess.run(
-        ["tmux", *args],
-        text=True,
-        capture_output=capture,
-        check=False,
-    )
+def _run_tmux(
+    args: Sequence[str], *, capture: bool = False, timeout_s: float | None = None
+) -> subprocess.CompletedProcess[str]:
+    kwargs: dict[str, object] = {
+        "text": True,
+        "capture_output": capture,
+        "check": False,
+    }
+    # Keep keyword list minimal for test fakes that don't accept extra kwargs.
+    if timeout_s is not None:
+        kwargs["timeout"] = timeout_s
+    return subprocess.run(["tmux", *args], **kwargs)  # type: ignore[arg-type]
 
 
 def _run_outer_tmux(
-    args: Sequence[str], *, capture: bool = False
+    args: Sequence[str], *, capture: bool = False, timeout_s: float | None = None
 ) -> subprocess.CompletedProcess[str]:
     """Run tmux commands against the dedicated outer server socket."""
-    return _run_tmux(["-L", OUTER_SOCKET, *args], capture=capture)
+    return _run_tmux(["-L", OUTER_SOCKET, *args], capture=capture, timeout_s=timeout_s)
 
 
 def _run_inner_tmux(
-    args: Sequence[str], *, capture: bool = False
+    args: Sequence[str], *, capture: bool = False, timeout_s: float | None = None
 ) -> subprocess.CompletedProcess[str]:
-    return _run_tmux(["-L", INNER_SOCKET, *args], capture=capture)
+    return _run_tmux(["-L", INNER_SOCKET, *args], capture=capture, timeout_s=timeout_s)
 
 
 def _python_dashboard_command() -> str:
@@ -196,16 +209,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")
+        logger.debug(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")
+        logger.debug(f"[PERF] _load_terminal_state_from_db list_agents: {_time.time() - t2:.3f}s")
 
         out: dict[str, dict[str, str]] = {}
         for agent in agents:
@@ -255,6 +269,12 @@ def _load_terminal_state_from_json() -> dict[str, dict[str, str]]:
         return {}
 
 
+_TERMINAL_STATE_CACHE_LOCK = threading.Lock()
+_TERMINAL_STATE_CACHE: dict[str, dict[str, str]] | None = None
+_TERMINAL_STATE_CACHE_AT: float = 0.0
+_TERMINAL_STATE_CACHE_TTL_S: float = 1.5
+
+
 def _load_terminal_state() -> dict[str, dict[str, str]]:
     """Load terminal state.
 
@@ -264,6 +284,13 @@ def _load_terminal_state() -> dict[str, dict[str, str]]:
 
     Merges both sources, with DB taking precedence.
     """
+    global _TERMINAL_STATE_CACHE, _TERMINAL_STATE_CACHE_AT
+    now = time.monotonic()
+    with _TERMINAL_STATE_CACHE_LOCK:
+        cache = _TERMINAL_STATE_CACHE
+        if cache is not None and (now - _TERMINAL_STATE_CACHE_AT) <= _TERMINAL_STATE_CACHE_TTL_S:
+            return dict(cache)
+
     # Phase 1: Load from database
     db_state = _load_terminal_state_from_db()
 
@@ -274,6 +301,10 @@ def _load_terminal_state() -> dict[str, dict[str, str]]:
     result = dict(json_state)
     result.update(db_state)
 
+    with _TERMINAL_STATE_CACHE_LOCK:
+        _TERMINAL_STATE_CACHE = dict(result)
+        _TERMINAL_STATE_CACHE_AT = time.monotonic()
+
     return result
 
 
@@ -470,6 +501,7 @@ def bootstrap_dashboard_into_tmux() -> None:
 
     # Enable mouse for the managed session only.
     _run_outer_tmux(["set-option", "-t", OUTER_SESSION, "mouse", "on"])
+    _disable_outer_border_resize()
 
     # Disable status bar for cleaner UI (Aline sessions only).
     _run_outer_tmux(["set-option", "-t", OUTER_SESSION, "status", "off"])
@@ -505,6 +537,9 @@ def bootstrap_dashboard_into_tmux() -> None:
     )
     _run_outer_tmux(["select-window", "-t", f"{OUTER_SESSION}:{OUTER_WINDOW}"])
 
+    # Best-effort: enforce a stable dashboard pane width if the terminal pane already exists.
+    _set_outer_dashboard_pane_width(DEFAULT_DASHBOARD_PANE_WIDTH_COLS)
+
     # Sanity-check before exec'ing into tmux attach. If this fails, fall back to non-tmux mode.
     ready = _run_outer_tmux(["has-session", "-t", OUTER_SESSION], capture=True)
     if ready.returncode != 0:
@@ -690,6 +725,7 @@ def ensure_right_pane(width_percent: int = 50) -> bool:
     )
     panes = _parse_lines(panes_out)
     if len(panes) >= 2:
+        _set_outer_dashboard_pane_width(DEFAULT_DASHBOARD_PANE_WIDTH_COLS)
         return True
 
     # Split from the dashboard pane to keep it on the left.
@@ -704,20 +740,156 @@ def ensure_right_pane(width_percent: int = 50) -> bool:
             f"{OUTER_SESSION}:{OUTER_WINDOW}.0",
             "-d",
             attach_cmd,
-        ]
+        ],
+        capture=True,
     )
-    return split.returncode == 0
+    if split.returncode != 0:
+        detail = (split.stderr or split.stdout or "").strip()
+        if detail:
+            logger.warning(f"ensure_right_pane split-window failed: {detail}")
+    if split.returncode == 0:
+        _set_outer_dashboard_pane_width(DEFAULT_DASHBOARD_PANE_WIDTH_COLS)
+        return True
+    return False
+
+
+def ensure_right_pane_ready(width_percent: int = 50) -> bool:
+    """Ensure the right pane exists and is attached to the inner tmux session."""
+    try:
+        ok = ensure_right_pane(width_percent)
+    except TypeError:
+        # Tests and some callers monkeypatch ensure_right_pane() as a no-arg lambda.
+        ok = ensure_right_pane()
+    if not ok:
+        return False
+
+    # Best-effort: enforce a stable dashboard pane width whenever we touch the outer layout.
+    _set_outer_dashboard_pane_width(DEFAULT_DASHBOARD_PANE_WIDTH_COLS)
+
+    attach_cmd = shlex.join(["tmux", "-L", INNER_SOCKET, "attach", "-t", INNER_SESSION])
+
+    # If the right pane exists but isn't running `tmux attach`, it may look "blank" or stale.
+    try:
+        proc = _run_outer_tmux(
+            [
+                "display-message",
+                "-p",
+                "-t",
+                f"{OUTER_SESSION}:{OUTER_WINDOW}.1",
+                "#{pane_current_command}",
+            ],
+            capture=True,
+        )
+        current_cmd = (proc.stdout or "").strip()
+    except Exception:
+        current_cmd = ""
+
+    if current_cmd and current_cmd != "tmux":
+        respawn = _run_outer_tmux(
+            [
+                "respawn-pane",
+                "-k",
+                "-t",
+                f"{OUTER_SESSION}:{OUTER_WINDOW}.1",
+                attach_cmd,
+            ],
+            capture=True,
+        )
+        if respawn.returncode != 0:
+            detail = (respawn.stderr or respawn.stdout or "").strip()
+            if detail:
+                logger.warning(f"ensure_right_pane_ready respawn failed: {detail}")
+            return False
+
+    return True
+
+
+def _disable_outer_border_resize() -> None:
+    """Disable mouse drag-to-resize on pane borders (outer dashboard tmux server only)."""
+    try:
+        # tmux enables border resizing via MouseDrag1Border. Unbind it on our dedicated server
+        # to avoid accidental resizing when selecting text near the pane divider.
+        for key in ("MouseDrag1Border", "MouseDown1Border", "MouseDragEnd1Border", "MouseUp1Border"):
+            _run_outer_tmux(["unbind-key", "-T", "root", key], capture=True)
+    except Exception:
+        return
+
+
+def _set_outer_dashboard_pane_width(width_cols: int) -> None:
+    """Best-effort: size the left dashboard pane to a fixed width (in terminal columns)."""
+    try:
+        w = int(width_cols)
+        if w <= 0:
+            return
+    except Exception:
+        return
+
+    try:
+        # Avoid assuming pane indexes are 0/1. Determine the leftmost pane by geometry.
+        panes_out = (
+            _run_outer_tmux(
+                [
+                    "list-panes",
+                    "-t",
+                    f"{OUTER_SESSION}:{OUTER_WINDOW}",
+                    "-F",
+                    "#{pane_id}\t#{pane_left}\t#{pane_index}",
+                ],
+                capture=True,
+                timeout_s=0.2,
+            ).stdout
+            or ""
+        )
+        panes: list[tuple[int, int, str]] = []
+        for line in _parse_lines(panes_out):
+            parts = line.split("\t")
+            if len(parts) < 2:
+                continue
+            pane_id = (parts[0] or "").strip()
+            if not pane_id:
+                continue
+            try:
+                pane_left = int((parts[1] or "0").strip())
+            except Exception:
+                continue
+            pane_index = 0
+            if len(parts) > 2 and (parts[2] or "").strip():
+                try:
+                    pane_index = int(parts[2].strip())
+                except Exception:
+                    pane_index = 0
+            panes.append((pane_left, pane_index, pane_id))
+
+        # Only enforce widths when there are two panes (dashboard + terminal).
+        if len(panes) < 2:
+            return
+
+        panes.sort(key=lambda t: (t[0], t[1]))
+        leftmost_pane_id = panes[0][2]
+        _run_outer_tmux(
+            ["resize-pane", "-t", leftmost_pane_id, "-x", str(w)],
+            capture=True,
+            timeout_s=0.2,
+        )
+    except Exception:
+        return
+
+
+def enforce_outer_dashboard_pane_width(width_cols: int = DEFAULT_DASHBOARD_PANE_WIDTH_COLS) -> None:
+    """Best-effort: enforce the fixed dashboard pane width for the outer tmux layout."""
+    _set_outer_dashboard_pane_width(width_cols)
 
 
 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")
+    logger.debug(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")
+    logger.debug(f"[PERF] list_inner_windows _load_terminal_state: {_time.time() - t1:.3f}s")
     out = (
         _run_inner_tmux(
             [
@@ -743,7 +915,7 @@ def list_inner_windows() -> list[InnerWindow]:
                 + OPT_CREATED_AT
                 + "}\t#{"
                 + OPT_NO_TRACK
-                + "}",
+                + "}\t#{pane_pid}\t#{pane_current_command}\t#{pane_tty}",
             ],
             capture=True,
         ).stdout
@@ -773,6 +945,15 @@ def list_inner_windows() -> list[InnerWindow]:
                 pass
         no_track_str = parts[11] if len(parts) > 11 and parts[11] else None
         no_track = no_track_str == "1"
+        pane_pid_str = parts[12] if len(parts) > 12 and parts[12] else None
+        pane_pid: int | None = None
+        if pane_pid_str:
+            try:
+                pane_pid = int(pane_pid_str)
+            except ValueError:
+                pass
+        pane_current_command = parts[13] if len(parts) > 13 and parts[13] else None
+        pane_tty = parts[14] if len(parts) > 14 and parts[14] else None
 
         if terminal_id:
             persisted = state.get(terminal_id) or {}
@@ -831,6 +1012,9 @@ def list_inner_windows() -> list[InnerWindow]:
                 attention=attention,
                 created_at=created_at,
                 no_track=no_track,
+                pane_pid=pane_pid,
+                pane_current_command=pane_current_command,
+                pane_tty=pane_tty,
             )
         )
     # Sort by creation time (newest first). Windows without created_at go to the bottom.
@@ -838,8 +1022,36 @@ def list_inner_windows() -> list[InnerWindow]:
     return windows
 
 
+def list_outer_panes(*, timeout_s: float = 0.2) -> list[str]:
+    """List panes in the outer dashboard window (best-effort).
+
+    Intended for lightweight watchdog checks; returns tab-delimited lines in the same
+    format as `collect_tmux_debug_state()["outer_panes"]["stdout"]`.
+    """
+    if not tmux_available():
+        return []
+    try:
+        proc = _run_outer_tmux(
+            [
+                "list-panes",
+                "-t",
+                f"{OUTER_SESSION}:{OUTER_WINDOW}",
+                "-F",
+                "#{pane_index}\t#{pane_active}\t#{pane_current_command}\t#{pane_pid}\t#{pane_tty}",
+            ],
+            capture=True,
+            timeout_s=timeout_s,
+        )
+    except Exception:
+        return []
+    if proc.returncode != 0:
+        return []
+    return [ln for ln in (proc.stdout or "").splitlines() if ln.strip()]
+
+
 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
@@ -848,7 +1060,7 @@ def set_inner_window_options(window_id: str, options: dict[str, str]) -> bool:
         # 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")
+        logger.debug(f"[PERF] set_inner_window_options {key}: {_time.time() - t0:.3f}s")
     return ok
 
 
@@ -868,15 +1080,17 @@ def create_inner_window(
     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():
+    logger.debug("[PERF] create_inner_window START")
+    if not ensure_right_pane_ready():
+        logger.warning("create_inner_window: right pane unavailable")
         return None
-    logger.info(f"[PERF] create_inner_window ensure_right_pane: {_time.time() - t0:.3f}s")
+    logger.debug(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")
+    logger.debug(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
@@ -897,8 +1111,11 @@ def create_inner_window(
         ],
         capture=True,
     )
-    logger.info(f"[PERF] create_inner_window new-window: {_time.time() - t2:.3f}s")
+    logger.debug(f"[PERF] create_inner_window new-window: {_time.time() - t2:.3f}s")
     if proc.returncode != 0:
+        detail = (proc.stderr or proc.stdout or "").strip()
+        if detail:
+            logger.warning(f"create_inner_window new-window failed: {detail}")
         return None
 
     created = _parse_lines(proc.stdout or "")
@@ -923,7 +1140,7 @@ def create_inner_window(
         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")
+    logger.debug(f"[PERF] create_inner_window set_options: {_time.time() - t3:.3f}s")
 
     _run_inner_tmux(["select-window", "-t", window_id])
 
@@ -939,19 +1156,26 @@ def create_inner_window(
 
 
 def select_inner_window(window_id: str) -> bool:
-    if not ensure_right_pane():
+    if not ensure_right_pane_ready():
+        return False
+    proc = _run_inner_tmux(["select-window", "-t", window_id], capture=True)
+    if proc.returncode != 0:
+        detail = (proc.stderr or proc.stdout or "").strip()
+        if detail:
+            logger.warning(f"select_inner_window failed ({window_id}): {detail}")
         return False
-    return _run_inner_tmux(["select-window", "-t", window_id]).returncode == 0
+    return True
 
 
 def focus_right_pane() -> bool:
     """Focus the right pane (terminal area) in the outer tmux layout."""
-    return (
-        _run_outer_tmux(
-            ["select-pane", "-t", f"{OUTER_SESSION}:{OUTER_WINDOW}.1"]
-        ).returncode
-        == 0
-    )
+    proc = _run_outer_tmux(["select-pane", "-t", f"{OUTER_SESSION}:{OUTER_WINDOW}.1"], capture=True)
+    if proc.returncode != 0:
+        detail = (proc.stderr or proc.stdout or "").strip()
+        if detail:
+            logger.warning(f"focus_right_pane failed: {detail}")
+        return False
+    return True
 
 
 def clear_attention(window_id: str) -> bool:
@@ -991,3 +1215,94 @@ def get_active_context_id(*, allowed_providers: set[str] | None = None) -> str |
 
     context_id = (active.context_id or "").strip()
     return context_id or None
+
+
+def collect_tmux_debug_state() -> dict[str, object]:
+    """Best-effort snapshot of tmux state for diagnosing blank/stuck panes.
+
+    This must be non-intrusive: it should not create sessions or change state.
+    """
+
+    def _cap(proc: subprocess.CompletedProcess[str] | None) -> dict[str, object]:
+        if proc is None:
+            return {}
+
+        def _trim(s: str | None) -> str:
+            text = (s or "").strip()
+            if len(text) > 4000:
+                return text[:4000] + "…(truncated)"
+            return text
+
+        return {
+            "rc": int(getattr(proc, "returncode", -1)),
+            "stdout": _trim(getattr(proc, "stdout", "")),
+            "stderr": _trim(getattr(proc, "stderr", "")),
+        }
+
+    state: dict[str, object] = {
+        "tmux_available": tmux_available(),
+        "in_tmux": in_tmux(),
+        "managed_env": managed_env_enabled(),
+        "outer_socket": OUTER_SOCKET,
+        "inner_socket": INNER_SOCKET,
+        "outer_session": OUTER_SESSION,
+        "outer_window": OUTER_WINDOW,
+        "inner_session": INNER_SESSION,
+    }
+
+    if not tmux_available():
+        return state
+
+    try:
+        state["outer_has_session"] = _cap(
+            _run_outer_tmux(["has-session", "-t", OUTER_SESSION], capture=True, timeout_s=0.5)
+        )
+        state["outer_panes"] = _cap(
+            _run_outer_tmux(
+                [
+                    "list-panes",
+                    "-t",
+                    f"{OUTER_SESSION}:{OUTER_WINDOW}",
+                    "-F",
+                    "#{pane_index}\t#{pane_active}\t#{pane_current_command}\t#{pane_pid}\t#{pane_tty}",
+                ],
+                capture=True,
+                timeout_s=0.5,
+            )
+        )
+    except Exception:
+        pass
+
+    try:
+        state["inner_has_session"] = _cap(
+            _run_inner_tmux(["has-session", "-t", INNER_SESSION], capture=True, timeout_s=0.5)
+        )
+        state["inner_windows"] = _cap(
+            _run_inner_tmux(
+                [
+                    "list-windows",
+                    "-t",
+                    INNER_SESSION,
+                    "-F",
+                    "#{window_id}\t#{window_index}\t#{window_name}\t#{window_active}\t#{"
+                    + OPT_TERMINAL_ID
+                    + "}\t#{"
+                    + OPT_PROVIDER
+                    + "}\t#{"
+                    + OPT_SESSION_TYPE
+                    + "}\t#{"
+                    + OPT_SESSION_ID
+                    + "}\t#{"
+                    + OPT_CONTEXT_ID
+                    + "}\t#{"
+                    + OPT_ATTENTION
+                    + "}",
+                ],
+                capture=True,
+                timeout_s=0.5,
+            )
+        )
+    except Exception:
+        pass
+
+    return state