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

realign/dashboard/terminal_backend.py

@@ -0,0 +1,110 @@
+"""Terminal backend interface for native terminal support.
+
+This module defines the protocol for terminal backends (iTerm2, Kitty)
+that allow the Aline Dashboard to control native terminal windows
+instead of using tmux for rendering.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Protocol, runtime_checkable
+
+
+@dataclass
+class TerminalInfo:
+    """Information about a terminal tab/window managed by a backend."""
+
+    terminal_id: str  # Aline internal ID (UUID)
+    session_id: str  # Backend-specific session ID (iTerm2 session_id or Kitty window_id)
+    name: str  # Display name
+    active: bool = False  # Whether this terminal is currently focused
+    claude_session_id: str | None = None  # Claude Code session ID if applicable
+    context_id: str | None = None  # Aline context ID
+    provider: str | None = None  # Terminal provider (claude, codex, etc.)
+    attention: str | None = None  # Attention state (permission_request, stop, etc.)
+    created_at: float | None = None  # Unix timestamp when terminal was created
+    metadata: dict[str, str] = field(default_factory=dict)  # Additional metadata
+
+
+@runtime_checkable
+class TerminalBackend(Protocol):
+    """Protocol for terminal backends.
+
+    Implementations must provide async methods to:
+    - Create new terminal tabs
+    - Focus/switch to existing tabs
+    - Close tabs
+    - List all managed tabs
+    """
+
+    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 terminal tab.
+
+        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:
+            Backend-specific session ID, or None if creation failed
+        """
+        ...
+
+    async def focus_tab(self, session_id: str, *, steal_focus: bool = False) -> bool:
+        """Switch to/focus a terminal tab.
+
+        Args:
+            session_id: Backend-specific session ID
+            steal_focus: If True, also bring the terminal window to front.
+                         If False, switch tab but keep focus on Dashboard.
+
+        Returns:
+            True if successful, False otherwise
+        """
+        ...
+
+    async def close_tab(self, session_id: str) -> bool:
+        """Close a terminal tab.
+
+        Args:
+            session_id: Backend-specific session ID
+
+        Returns:
+            True if successful, False otherwise
+        """
+        ...
+
+    async def list_tabs(self) -> list[TerminalInfo]:
+        """List all terminal tabs managed by this backend.
+
+        Returns:
+            List of TerminalInfo objects for each managed tab
+        """
+        ...
+
+    async def is_available(self) -> bool:
+        """Check if this backend is available and usable.
+
+        Returns:
+            True if the backend can be used, False otherwise
+        """
+        ...
+
+    def get_backend_name(self) -> str:
+        """Get the human-readable name of this backend.
+
+        Returns:
+            Backend name (e.g., "iTerm2", "Kitty")
+        """
+        ...

realign/dashboard/widgets/events_table.py

@@ -232,6 +232,8 @@ class EventsTable(Container):
         table.add_column("Share", key="share", width=12)
         table.add_column("Type", key="type", width=8)
         table.add_column("Sessions", key="sessions", width=8)
+        table.add_column("Created By", key="created_by", width=10)
+        table.add_column("Shared By", key="shared_by", width=10)
         table.add_column("Event ID", key="event_id", width=12)
         table.add_column("Created", key="created", width=10)
         table.cursor_type = "row"
@@ -352,6 +354,12 @@ class EventsTable(Container):
                 table.update_cell(
                     eid, "sessions", self._format_cell(str(event["sessions"]), eid)
                 )
+                table.update_cell(
+                    eid, "created_by", self._format_cell(event.get("created_by", "-"), eid)
+                )
+                table.update_cell(
+                    eid, "shared_by", self._format_cell(event.get("shared_by", "-"), eid)
+                )
                 table.update_cell(
                     eid, "event_id", self._format_cell(event["short_id"], eid)
                 )
@@ -736,6 +744,8 @@ class EventsTable(Container):
                         e.event_type,
                         e.created_at,
                         e.share_url,
+                        e.created_by,
+                        e.shared_by,
                         (SELECT COUNT(*) FROM event_sessions WHERE event_id = e.id) AS session_count
                     FROM events e
                     ORDER BY e.created_at DESC
@@ -743,8 +753,9 @@ class EventsTable(Container):
                     """,
                     (int(rows_per_page), int(offset)),
                 ).fetchall()
-                has_share_url = True
+                has_new_columns = True
             except Exception:
+                # Fallback for older schema without created_by/shared_by
                 rows = conn.execute(
                     """
                     SELECT
@@ -759,18 +770,22 @@ class EventsTable(Container):
                     """,
                     (int(rows_per_page), int(offset)),
                 ).fetchall()
-                has_share_url = False
+                has_new_columns = False
 
             for i, row in enumerate(rows):
                 event_id = row[0]
                 title = row[1] or "(no title)"
                 event_type = row[2] or "unknown"
                 created_at = row[3]
-                if has_share_url:
+                if has_new_columns:
                     share_url = row[4]
-                    session_count = row[5]
+                    created_by = row[5]
+                    shared_by = row[6]
+                    session_count = row[7]
                 else:
                     share_url = None
+                    created_by = None
+                    shared_by = None
                     session_count = row[4]
 
                 # Format event type
@@ -789,6 +804,26 @@ class EventsTable(Container):
                     except Exception:
                         created_str = created_at
 
+                # Look up user names from users table
+                created_by_display = "-"
+                shared_by_display = "-"
+                if created_by:
+                    try:
+                        user_row = conn.execute(
+                            "SELECT user_name FROM users WHERE uid = ?", (created_by,)
+                        ).fetchone()
+                        created_by_display = user_row[0] if user_row and user_row[0] else created_by[:8] + "..."
+                    except Exception:
+                        created_by_display = created_by[:8] + "..." if len(created_by) > 8 else created_by
+                if shared_by:
+                    try:
+                        user_row = conn.execute(
+                            "SELECT user_name FROM users WHERE uid = ?", (shared_by,)
+                        ).fetchone()
+                        shared_by_display = user_row[0] if user_row and user_row[0] else shared_by[:8] + "..."
+                    except Exception:
+                        shared_by_display = shared_by[:8] + "..." if len(shared_by) > 8 else shared_by
+
                 events.append(
                     {
                         "index": offset + i + 1,
@@ -799,6 +834,8 @@ class EventsTable(Container):
                         "sessions": session_count,
                         "share_url": share_url,
                         "share_id": self._extract_share_id(share_url),
+                        "created_by": created_by_display,
+                        "shared_by": shared_by_display,
                         "created": created_str,
                     }
                 )
@@ -849,7 +886,7 @@ class EventsTable(Container):
             if self.wrap_mode and event.get("share_url"):
                 share_val = event.get("share_url")
 
-            # Column order: ✓, #, Title, Share, Type, Sessions, Event ID, Created
+            # Column order: ✓, #, Title, Share, Type, Sessions, Created By, Shared By, Event ID, Created
             table.add_row(
                 self._checkbox_cell(eid),
                 self._format_cell(str(event["index"]), eid),
@@ -857,6 +894,8 @@ class EventsTable(Container):
                 self._format_cell(share_val, eid),
                 self._format_cell(event["type"], eid),
                 self._format_cell(str(event["sessions"]), eid),
+                self._format_cell(event.get("created_by", "-"), eid),
+                self._format_cell(event.get("shared_by", "-"), eid),
                 self._format_cell(event["short_id"], eid),
                 self._format_cell(event["created"], eid),
                 key=eid,

realign/dashboard/widgets/sessions_table.py

@@ -223,6 +223,8 @@ class SessionsTable(Container):
         table.add_column("Project", key="project", width=15)
         table.add_column("Source", key="source", width=10)
         table.add_column("Turns", key="turns", width=6)
+        table.add_column("Created By", key="created_by", width=10)
+        table.add_column("Shared By", key="shared_by", width=10)
         table.add_column("Session ID", key="session_id", width=20)
         table.add_column("Last Activity", key="last_activity", width=12)
         table.cursor_type = "row"
@@ -361,6 +363,12 @@ class SessionsTable(Container):
                 table.update_cell(
                     sid, "turns", self._format_cell(str(session["turns"]), sid)
                 )
+                table.update_cell(
+                    sid, "created_by", self._format_cell(session.get("created_by", "-"), sid)
+                )
+                table.update_cell(
+                    sid, "shared_by", self._format_cell(session.get("shared_by", "-"), sid)
+                )
                 table.update_cell(
                     sid, "session_id", self._format_cell(session["short_id"], sid)
                 )
@@ -805,21 +813,43 @@ class SessionsTable(Container):
                 # Get paginated sessions
                 # Use cached total_turns instead of subquery for performance
                 offset = (int(page) - 1) * int(rows_per_page)
-                rows = conn.execute(
-                    """
-                    SELECT
-                        s.id,
-                        s.session_type,
-                        s.workspace_path,
-                        s.session_title,
-                        s.last_activity_at,
-                        s.total_turns
-                    FROM sessions s
-                    ORDER BY s.last_activity_at DESC
-                    LIMIT ? OFFSET ?
-                """,
-                    (int(rows_per_page), int(offset)),
-                ).fetchall()
+                try:
+                    rows = conn.execute(
+                        """
+                        SELECT
+                            s.id,
+                            s.session_type,
+                            s.workspace_path,
+                            s.session_title,
+                            s.last_activity_at,
+                            s.total_turns,
+                            s.created_by,
+                            s.shared_by
+                        FROM sessions s
+                        ORDER BY s.last_activity_at DESC
+                        LIMIT ? OFFSET ?
+                    """,
+                        (int(rows_per_page), int(offset)),
+                    ).fetchall()
+                    has_new_columns = True
+                except Exception:
+                    # Fallback for older schema without created_by/shared_by
+                    rows = conn.execute(
+                        """
+                        SELECT
+                            s.id,
+                            s.session_type,
+                            s.workspace_path,
+                            s.session_title,
+                            s.last_activity_at,
+                            s.total_turns
+                        FROM sessions s
+                        ORDER BY s.last_activity_at DESC
+                        LIMIT ? OFFSET ?
+                    """,
+                        (int(rows_per_page), int(offset)),
+                    ).fetchall()
+                    has_new_columns = False
 
                 for i, row in enumerate(rows):
                     session_id = row[0]
@@ -828,6 +858,12 @@ class SessionsTable(Container):
                     title = row[3] or "(no title)"
                     last_activity = row[4]
                     turn_count = row[5]
+                    if has_new_columns:
+                        created_by = row[6]
+                        shared_by = row[7]
+                    else:
+                        created_by = None
+                        shared_by = None
 
                     source_map = {
                         "claude": "Claude",
@@ -846,6 +882,26 @@ class SessionsTable(Container):
                         except Exception:
                             activity_str = last_activity
 
+                    # Look up user names from users table
+                    created_by_display = "-"
+                    shared_by_display = "-"
+                    if created_by:
+                        try:
+                            user_row = conn.execute(
+                                "SELECT user_name FROM users WHERE uid = ?", (created_by,)
+                            ).fetchone()
+                            created_by_display = user_row[0] if user_row and user_row[0] else created_by[:8] + "..."
+                        except Exception:
+                            created_by_display = created_by[:8] + "..." if len(created_by) > 8 else created_by
+                    if shared_by:
+                        try:
+                            user_row = conn.execute(
+                                "SELECT user_name FROM users WHERE uid = ?", (shared_by,)
+                            ).fetchone()
+                            shared_by_display = user_row[0] if user_row and user_row[0] else shared_by[:8] + "..."
+                        except Exception:
+                            shared_by_display = shared_by[:8] + "..." if len(shared_by) > 8 else shared_by
+
                     sessions.append(
                         {
                             "index": offset + i + 1,
@@ -855,6 +911,8 @@ class SessionsTable(Container):
                             "project": project,
                             "turns": turn_count,
                             "title": title,
+                            "created_by": created_by_display,
+                            "shared_by": shared_by_display,
                             "last_activity": activity_str,
                         }
                     )
@@ -905,7 +963,7 @@ class SessionsTable(Container):
             if self.wrap_mode:
                 display_id = sid
 
-            # Column order: ✓, #, Title, Project, Source, Turns, Session ID, Last Activity
+            # Column order: ✓, #, Title, Project, Source, Turns, Created By, Shared By, Session ID, Last Activity
             table.add_row(
                 self._checkbox_cell(sid),
                 self._format_cell(str(session["index"]), sid),
@@ -913,6 +971,8 @@ class SessionsTable(Container):
                 self._format_cell(session["project"], sid),
                 self._format_cell(session["source"], sid),
                 self._format_cell(str(session["turns"]), sid),
+                self._format_cell(session.get("created_by", "-"), sid),
+                self._format_cell(session.get("shared_by", "-"), sid),
                 self._format_cell(display_id, sid),
                 self._format_cell(session["last_activity"], sid),
                 key=sid,