aline-ai 0.6.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

realign/dashboard/backends/kitty.py

@@ -0,0 +1,372 @@
+"""Kitty terminal backend using the remote control protocol.
+
+This backend allows the Aline Dashboard to create and manage terminal tabs
+directly in Kitty, bypassing tmux for rendering. This provides native
+terminal performance and features.
+
+Requirements:
+    Kitty must be configured with remote control enabled:
+
+    In ~/.config/kitty/kitty.conf:
+        allow_remote_control yes
+        listen_on unix:/tmp/kitty_aline
+
+    Or start kitty with:
+        kitty --listen-on unix:/tmp/kitty_aline
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import shutil
+import subprocess
+import time
+from typing import Any
+
+from ..terminal_backend import TerminalBackend, TerminalInfo
+from ...logging_config import setup_logger
+
+logger = setup_logger("realign.dashboard.backends.kitty", "dashboard.log")
+
+# Environment variable used to identify Aline-managed terminals
+ENV_TERMINAL_ID = "ALINE_TERMINAL_ID"
+ENV_CONTEXT_ID = "ALINE_CONTEXT_ID"
+ENV_TERMINAL_PROVIDER = "ALINE_TERMINAL_PROVIDER"
+
+# Default socket path for Kitty remote control
+DEFAULT_SOCKET = "/tmp/kitty_aline"
+
+
+class KittyBackend:
+    """Kitty terminal backend using remote control."""
+
+    def __init__(self, socket: str = DEFAULT_SOCKET) -> None:
+        self.socket = socket
+        self._terminals: dict[str, TerminalInfo] = {}  # terminal_id -> TerminalInfo
+        self._window_to_terminal: dict[str, str] = {}  # kitty window_id -> terminal_id
+
+    def get_backend_name(self) -> str:
+        return "Kitty"
+
+    async def is_available(self) -> bool:
+        """Check if Kitty and remote control are available."""
+        # Check if kitty is installed
+        if not shutil.which("kitty"):
+            logger.debug("Kitty not found in PATH")
+            return False
+
+        # Check if kitten (Kitty's helper) is available
+        if not shutil.which("kitten"):
+            logger.debug("kitten command not found")
+            return False
+
+        # Check if the socket exists (Kitty is running with remote control)
+        if not os.path.exists(self.socket):
+            logger.debug(f"Kitty socket not found: {self.socket}")
+            return False
+
+        # Try to connect
+        result = await self._run_kitten("ls")
+        return result is not None
+
+    async def _run_kitten(self, *args: str) -> dict[str, Any] | list[Any] | None:
+        """Run a kitten @ command and return JSON output.
+
+        Args:
+            *args: Arguments to pass to kitten @
+
+        Returns:
+            Parsed JSON response, or None on error
+        """
+        cmd = ["kitten", "@", "--to", f"unix:{self.socket}", *args]
+
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                *cmd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+            stdout, stderr = await proc.communicate()
+
+            if proc.returncode != 0:
+                if stderr:
+                    logger.debug(f"kitten error: {stderr.decode()}")
+                return None
+
+            if stdout:
+                try:
+                    return json.loads(stdout.decode())
+                except json.JSONDecodeError:
+                    # Some commands return non-JSON output
+                    return {"output": stdout.decode().strip()}
+
+            return {}
+
+        except Exception as e:
+            logger.error(f"Failed to run kitten command: {e}")
+            return None
+
+    async def _run_kitten_simple(self, *args: str) -> str | None:
+        """Run a kitten @ command and return raw output.
+
+        Args:
+            *args: Arguments to pass to kitten @
+
+        Returns:
+            Raw stdout, or None on error
+        """
+        cmd = ["kitten", "@", "--to", f"unix:{self.socket}", *args]
+
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                *cmd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+            stdout, stderr = await proc.communicate()
+
+            if proc.returncode != 0:
+                if stderr:
+                    logger.debug(f"kitten error: {stderr.decode()}")
+                return None
+
+            return stdout.decode().strip() if stdout else ""
+
+        except Exception as e:
+            logger.error(f"Failed to run kitten command: {e}")
+            return None
+
+    async def create_tab(
+        self,
+        command: str,
+        terminal_id: str,
+        *,
+        name: str | None = None,
+        env: dict[str, str] | None = None,
+        cwd: str | None = None,
+    ) -> str | None:
+        """Create a new tab in Kitty.
+
+        Args:
+            command: The command to run in the new tab
+            terminal_id: Aline internal terminal ID
+            name: Optional display name for the tab
+            env: Optional environment variables to set
+            cwd: Optional working directory
+
+        Returns:
+            Kitty window ID (as string), or None if creation failed
+        """
+        created_at = time.time()
+
+        # Build environment with Aline identifiers
+        full_env = dict(env or {})
+        full_env[ENV_TERMINAL_ID] = terminal_id
+
+        # Build kitten launch arguments
+        args = ["launch", "--type=tab"]
+
+        # Add environment variables
+        for key, value in full_env.items():
+            args.extend(["--env", f"{key}={value}"])
+
+        # Add working directory
+        if cwd:
+            args.extend(["--cwd", cwd])
+
+        # Add tab title
+        if name:
+            args.extend(["--tab-title", name])
+
+        # Add the command (as a shell command)
+        args.append(f"/bin/zsh -lc {_shell_quote(command)}")
+
+        # Run the launch command
+        result = await self._run_kitten_simple(*args)
+
+        if result is None:
+            logger.error("Failed to create Kitty tab")
+            return None
+
+        # The launch command returns the window ID
+        window_id = result.strip()
+        if not window_id:
+            logger.error("No window ID returned from Kitty launch")
+            return None
+
+        logger.info(
+            f"Created Kitty tab: window_id={window_id}, terminal_id={terminal_id}"
+        )
+
+        # Track the terminal
+        info = TerminalInfo(
+            terminal_id=terminal_id,
+            session_id=window_id,
+            name=name or "Terminal",
+            active=True,
+            provider=full_env.get(ENV_TERMINAL_PROVIDER),
+            context_id=full_env.get(ENV_CONTEXT_ID),
+            created_at=created_at,
+        )
+        self._terminals[terminal_id] = info
+        self._window_to_terminal[window_id] = terminal_id
+
+        return window_id
+
+    async def focus_tab(self, session_id: str, *, steal_focus: bool = False) -> bool:
+        """Switch to a terminal tab.
+
+        Args:
+            session_id: Kitty window ID
+            steal_focus: If True, also bring Kitty window to front
+
+        Returns:
+            True if successful
+        """
+        # Focus the window/tab
+        result = await self._run_kitten_simple(
+            "focus-window", "--match", f"id:{session_id}"
+        )
+
+        if result is None:
+            logger.warning(f"Failed to focus Kitty window: {session_id}")
+            return False
+
+        logger.debug(f"Focused Kitty tab: window_id={session_id}")
+
+        # If not stealing focus, try to return focus to the previous app
+        # Note: Kitty doesn't have a direct way to do this, so we rely on
+        # the window manager. On macOS, we could use AppleScript.
+        if not steal_focus:
+            # Best effort: the focus-window command in Kitty typically
+            # doesn't steal app focus, just switches the active tab
+            pass
+
+        return True
+
+    async def close_tab(self, session_id: str) -> bool:
+        """Close a terminal tab.
+
+        Args:
+            session_id: Kitty window ID
+
+        Returns:
+            True if successful
+        """
+        result = await self._run_kitten_simple(
+            "close-window", "--match", f"id:{session_id}"
+        )
+
+        if result is None:
+            logger.warning(f"Failed to close Kitty window: {session_id}")
+            return False
+
+        logger.info(f"Closed Kitty window: {session_id}")
+
+        # Clean up tracking
+        if session_id in self._window_to_terminal:
+            terminal_id = self._window_to_terminal.pop(session_id)
+            self._terminals.pop(terminal_id, None)
+
+        return True
+
+    async def list_tabs(self) -> list[TerminalInfo]:
+        """List all Aline-managed terminal tabs in Kitty.
+
+        Returns:
+            List of TerminalInfo for managed tabs
+        """
+        result = await self._run_kitten("ls")
+
+        if result is None:
+            return []
+
+        tabs: list[TerminalInfo] = []
+
+        # Parse the Kitty ls output
+        # Structure: [{"id": os_window_id, "tabs": [{"id": tab_id, "windows": [...]}]}]
+        try:
+            os_windows = result if isinstance(result, list) else []
+
+            for os_window in os_windows:
+                if not isinstance(os_window, dict):
+                    continue
+
+                for tab in os_window.get("tabs", []):
+                    if not isinstance(tab, dict):
+                        continue
+
+                    for window in tab.get("windows", []):
+                        if not isinstance(window, dict):
+                            continue
+
+                        window_id = str(window.get("id", ""))
+                        is_focused = window.get("is_focused", False)
+
+                        # Check if this is an Aline-managed terminal
+                        terminal_id = self._window_to_terminal.get(window_id)
+                        if terminal_id and terminal_id in self._terminals:
+                            info = self._terminals[terminal_id]
+                            tabs.append(
+                                TerminalInfo(
+                                    terminal_id=info.terminal_id,
+                                    session_id=window_id,
+                                    name=info.name,
+                                    active=is_focused,
+                                    claude_session_id=info.claude_session_id,
+                                    context_id=info.context_id,
+                                    provider=info.provider,
+                                    attention=info.attention,
+                                    created_at=info.created_at,
+                                    metadata=info.metadata,
+                                )
+                            )
+
+        except Exception as e:
+            logger.error(f"Failed to parse Kitty ls output: {e}")
+            return []
+
+        # Sort by creation time (newest first)
+        tabs.sort(
+            key=lambda t: t.created_at if t.created_at is not None else 0, reverse=True
+        )
+        return tabs
+
+    def update_terminal_info(
+        self, terminal_id: str, **kwargs: str | None
+    ) -> bool:
+        """Update metadata for a tracked terminal.
+
+        Args:
+            terminal_id: Aline internal terminal ID
+            **kwargs: Fields to update
+
+        Returns:
+            True if terminal was found and updated
+        """
+        if terminal_id not in self._terminals:
+            return False
+
+        info = self._terminals[terminal_id]
+        self._terminals[terminal_id] = TerminalInfo(
+            terminal_id=info.terminal_id,
+            session_id=info.session_id,
+            name=info.name,
+            active=info.active,
+            claude_session_id=kwargs.get("claude_session_id") or info.claude_session_id,
+            context_id=kwargs.get("context_id") or info.context_id,
+            provider=kwargs.get("provider") or info.provider,
+            attention=kwargs.get("attention"),  # Allow clearing attention
+            created_at=info.created_at,
+            metadata=info.metadata,
+        )
+        return True
+
+
+def _shell_quote(s: str) -> str:
+    """Quote a string for shell use."""
+    import shlex
+
+    return shlex.quote(s)

realign/dashboard/layout.py

@@ -0,0 +1,320 @@
+"""Window layout utilities for native terminal mode.
+
+This module provides functions to arrange the Aline Dashboard and native
+terminal windows (iTerm2/Kitty) in a side-by-side layout.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+
+from ..logging_config import setup_logger
+
+logger = setup_logger("realign.dashboard.layout", "dashboard.log")
+
+
+def get_screen_size() -> tuple[int, int]:
+    """Get the main screen size on macOS.
+
+    Returns:
+        (width, height) in pixels
+    """
+    if sys.platform != "darwin":
+        # Default fallback for non-macOS
+        return (1920, 1080)
+
+    try:
+        # Use system_profiler to get display resolution
+        result = subprocess.run(
+            [
+                "system_profiler",
+                "SPDisplaysDataType",
+                "-json",
+            ],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+
+        if result.returncode == 0 and result.stdout:
+            import json
+
+            data = json.loads(result.stdout)
+            displays = data.get("SPDisplaysDataType", [])
+            for display in displays:
+                for monitor in display.get("spdisplays_ndrvs", []):
+                    resolution = monitor.get("_spdisplays_resolution", "")
+                    # Parse resolution like "2560 x 1440"
+                    if " x " in resolution:
+                        parts = resolution.split(" x ")
+                        try:
+                            width = int(parts[0].strip())
+                            height = int(parts[1].split()[0].strip())
+                            return (width, height)
+                        except (ValueError, IndexError):
+                            continue
+
+    except Exception as e:
+        logger.debug(f"Failed to get screen size via system_profiler: {e}")
+
+    # Fallback: try AppKit
+    try:
+        import AppKit
+
+        screen = AppKit.NSScreen.mainScreen()
+        if screen:
+            frame = screen.frame()
+            return (int(frame.size.width), int(frame.size.height))
+    except Exception as e:
+        logger.debug(f"Failed to get screen size via AppKit: {e}")
+
+    # Default fallback
+    return (1920, 1080)
+
+
+def setup_side_by_side_layout(
+    terminal_app: str = "iTerm2",
+    dashboard_on_left: bool = True,
+    dashboard_width_percent: int = 50,
+) -> bool:
+    """Set up side-by-side layout for Dashboard and terminal windows.
+
+    Arranges the Dashboard and terminal app windows to fill the screen
+    side by side, without using full-screen mode.
+
+    Args:
+        terminal_app: Terminal application name ("iTerm2" or "Kitty")
+        dashboard_on_left: If True, Dashboard on left, terminal on right
+        dashboard_width_percent: Percentage of screen width for Dashboard (default 50)
+
+    Returns:
+        True if layout was set successfully
+    """
+    if sys.platform != "darwin":
+        logger.warning("Side-by-side layout only supported on macOS")
+        return False
+
+    width, height = get_screen_size()
+    menu_bar_height = 25  # Approximate macOS menu bar height
+
+    dashboard_width = int(width * dashboard_width_percent / 100)
+    terminal_width = width - dashboard_width
+
+    if dashboard_on_left:
+        dashboard_x = 0
+        terminal_x = dashboard_width
+    else:
+        terminal_x = 0
+        dashboard_x = terminal_width
+
+    # Get the hosting terminal app (the one running the Dashboard)
+    hosting_app = _detect_hosting_terminal()
+
+    success = True
+
+    # Position the hosting terminal (Dashboard)
+    if hosting_app:
+        if not _set_window_bounds(
+            hosting_app,
+            dashboard_x,
+            menu_bar_height,
+            dashboard_x + dashboard_width,
+            height,
+        ):
+            success = False
+
+    # Position the target terminal app (for the terminal tabs)
+    if terminal_app and terminal_app != hosting_app:
+        if not _set_window_bounds(
+            terminal_app,
+            terminal_x,
+            menu_bar_height,
+            terminal_x + terminal_width,
+            height,
+        ):
+            success = False
+
+    return success
+
+
+def _detect_hosting_terminal() -> str | None:
+    """Detect which terminal app is hosting the current process.
+
+    Returns:
+        Terminal app name ("Terminal", "iTerm2", "Kitty") or None
+    """
+    term_program = os.environ.get("TERM_PROGRAM", "").strip()
+
+    if term_program in {"Apple_Terminal", "Terminal.app"}:
+        return "Terminal"
+    if term_program in {"iTerm.app", "iTerm2"} or term_program.startswith("iTerm"):
+        return "iTerm2"
+    if term_program == "kitty":
+        return "Kitty"
+
+    # Try to detect via parent process
+    try:
+        import psutil
+
+        proc = psutil.Process()
+        for parent in proc.parents():
+            name = parent.name().lower()
+            if "iterm" in name:
+                return "iTerm2"
+            if "terminal" in name:
+                return "Terminal"
+            if "kitty" in name:
+                return "Kitty"
+    except Exception:
+        pass
+
+    return None
+
+
+def _set_window_bounds(
+    app_name: str, x1: int, y1: int, x2: int, y2: int
+) -> bool:
+    """Set window bounds for an application using AppleScript.
+
+    Args:
+        app_name: Application name
+        x1, y1: Top-left corner coordinates
+        x2, y2: Bottom-right corner coordinates
+
+    Returns:
+        True if successful
+    """
+    if sys.platform != "darwin":
+        return False
+
+    # Map app names to their AppleScript names
+    script_app_name = app_name
+    if app_name == "Kitty":
+        # Kitty doesn't support AppleScript well, use alternative method
+        return _set_kitty_window_bounds(x1, y1, x2, y2)
+
+    # Build AppleScript
+    script = f'''
+    tell application "{script_app_name}"
+        if (count of windows) > 0 then
+            set bounds of front window to {{{x1}, {y1}, {x2}, {y2}}}
+        end if
+    end tell
+    '''
+
+    try:
+        result = subprocess.run(
+            ["osascript", "-e", script],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+
+        if result.returncode != 0:
+            logger.warning(
+                f"Failed to set {app_name} window bounds: {result.stderr}"
+            )
+            return False
+
+        logger.debug(f"Set {app_name} window bounds: ({x1}, {y1}, {x2}, {y2})")
+        return True
+
+    except Exception as e:
+        logger.error(f"Failed to set {app_name} window bounds: {e}")
+        return False
+
+
+def _set_kitty_window_bounds(x1: int, y1: int, x2: int, y2: int) -> bool:
+    """Set Kitty window bounds using its remote control.
+
+    Kitty doesn't support AppleScript, so we use its native resize command.
+    However, Kitty's remote control doesn't support window positioning,
+    so we fall back to AppleScript via System Events.
+
+    Args:
+        x1, y1: Top-left corner coordinates
+        x2, y2: Bottom-right corner coordinates
+
+    Returns:
+        True if successful
+    """
+    # Try using System Events (requires accessibility permissions)
+    script = f'''
+    tell application "System Events"
+        tell process "kitty"
+            if (count of windows) > 0 then
+                set position of front window to {{{x1}, {y1}}}
+                set size of front window to {{{x2 - x1}, {y2 - y1}}}
+            end if
+        end tell
+    end tell
+    '''
+
+    try:
+        result = subprocess.run(
+            ["osascript", "-e", script],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+
+        if result.returncode != 0:
+            logger.warning(f"Failed to set Kitty window bounds: {result.stderr}")
+            return False
+
+        logger.debug(f"Set Kitty window bounds: ({x1}, {y1}, {x2}, {y2})")
+        return True
+
+    except Exception as e:
+        logger.error(f"Failed to set Kitty window bounds: {e}")
+        return False
+
+
+def bring_app_to_front(app_name: str) -> bool:
+    """Bring an application to the front.
+
+    Args:
+        app_name: Application name
+
+    Returns:
+        True if successful
+    """
+    if sys.platform != "darwin":
+        return False
+
+    script = f'''
+    tell application "{app_name}"
+        activate
+    end tell
+    '''
+
+    try:
+        result = subprocess.run(
+            ["osascript", "-e", script],
+            capture_output=True,
+            text=True,
+            timeout=2,
+        )
+        return result.returncode == 0
+    except Exception:
+        return False
+
+
+def focus_window_without_raising(app_name: str) -> bool:
+    """Focus an application's window without bringing it to the front.
+
+    This is tricky on macOS - we want to switch the active tab/window
+    within the app without stealing focus from the current app.
+
+    Args:
+        app_name: Application name
+
+    Returns:
+        True if successful (best effort)
+    """
+    # This is inherently difficult on macOS. The best we can do is
+    # use the terminal backend's focus_tab with steal_focus=False.
+    # This function is here for API completeness.
+    return True