aline-ai 0.7.3__py3-none-any.whl → 0.7.5__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,11 @@ 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
+_STATE_BORDER_RESIZE_ENABLED_KEY = "tmux_border_resize_enabled"
+
 
 @dataclass(frozen=True)
 class InnerWindow:
@@ -62,6 +68,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 +102,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:
@@ -256,6 +270,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.
 
@@ -265,6 +285,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()
 
@@ -275,6 +302,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
 
 
@@ -471,6 +502,13 @@ 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()
+    try:
+        from .state import set_dashboard_state_value
+
+        set_dashboard_state_value(_STATE_BORDER_RESIZE_ENABLED_KEY, False)
+    except Exception:
+        pass
 
     # Disable status bar for cleaner UI (Aline sessions only).
     _run_outer_tmux(["set-option", "-t", OUTER_SESSION, "status", "off"])
@@ -506,6 +544,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.
+    enforce_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:
@@ -691,6 +732,7 @@ def ensure_right_pane(width_percent: int = 50) -> bool:
     )
     panes = _parse_lines(panes_out)
     if len(panes) >= 2:
+        enforce_outer_dashboard_pane_width(DEFAULT_DASHBOARD_PANE_WIDTH_COLS)
         return True
 
     # Split from the dashboard pane to keep it on the left.
@@ -705,9 +747,157 @@ 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:
+        enforce_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
+    # (unless user enabled drag-to-resize).
+    enforce_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 outer_border_resize_enabled() -> bool:
+    """Return True when user has enabled tmux border drag-to-resize in the dashboard."""
+    try:
+        from .state import get_dashboard_state_value
+
+        return bool(get_dashboard_state_value(_STATE_BORDER_RESIZE_ENABLED_KEY, False))
+    except Exception:
+        return False
+
+
+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."""
+    if outer_border_resize_enabled():
+        return
+    _set_outer_dashboard_pane_width(width_cols)
 
 
 def list_inner_windows() -> list[InnerWindow]:
@@ -745,7 +935,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
@@ -775,6 +965,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 {}
@@ -833,6 +1032,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.
@@ -840,6 +1042,33 @@ 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
 
@@ -874,7 +1103,8 @@ def create_inner_window(
 
     t0 = _time.time()
     logger.debug("[PERF] create_inner_window START")
-    if not ensure_right_pane():
+    if not ensure_right_pane_ready():
+        logger.warning("create_inner_window: right pane unavailable")
         return None
     logger.debug(f"[PERF] create_inner_window ensure_right_pane: {_time.time() - t0:.3f}s")
 
@@ -903,6 +1133,9 @@ def create_inner_window(
     )
     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 "")
@@ -943,16 +1176,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
-    return _run_inner_tmux(["select-window", "-t", window_id]).returncode == 0
+    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 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:
@@ -992,3 +1235,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