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

realign/dashboard/widgets/config_panel.py

@@ -1,14 +1,31 @@
 """Config Panel Widget for viewing and editing configuration."""
 
+import threading
+import webbrowser
 from dataclasses import fields
 from pathlib import Path
 from typing import Optional
 
 from textual.app import ComposeResult
-from textual.containers import Horizontal
+from textual.containers import Horizontal, Vertical
 from textual.widgets import Button, DataTable, Input, Static, Switch
 
 from ..tmux_manager import _run_outer_tmux, OUTER_SESSION
+from ...auth import (
+    load_credentials,
+    save_credentials,
+    clear_credentials,
+    open_login_page,
+    is_logged_in,
+    get_current_user,
+    find_free_port,
+    start_callback_server,
+    validate_cli_token,
+)
+from ...config import ReAlignConfig
+from ...logging_config import setup_logger
+
+logger = setup_logger("realign.dashboard.widgets.config_panel", "dashboard.log")
 
 
 class ConfigPanel(Static):
@@ -74,6 +91,21 @@ class ConfigPanel(Static):
     ConfigPanel .tmux-settings Switch {
         width: auto;
     }
+
+    ConfigPanel .account-section {
+        height: auto;
+        margin-top: 1;
+        padding: 1;
+        border: solid $success;
+    }
+
+    ConfigPanel .account-section .account-status {
+        margin-bottom: 1;
+    }
+
+    ConfigPanel .account-section Button {
+        margin-right: 1;
+    }
     """
 
     def __init__(self) -> None:
@@ -83,6 +115,8 @@ class ConfigPanel(Static):
         self._selected_key: Optional[str] = None
         self._border_resize_enabled: bool = True  # Track tmux border resize state
         self._syncing_switch: bool = False  # Flag to prevent recursive switch updates
+        self._login_in_progress: bool = False  # Track login state
+        self._refresh_timer = None  # Timer for auto-refresh
 
     def compose(self) -> ComposeResult:
         """Compose the config panel layout."""
@@ -96,6 +130,14 @@ class ConfigPanel(Static):
             yield Button("Save", id="save-btn", variant="primary")
             yield Button("Reload", id="reload-btn", variant="default")
 
+        # Account section
+        with Static(classes="account-section"):
+            yield Static("[bold]Account[/bold]", classes="section-title")
+            yield Static(id="account-status", classes="account-status")
+            with Horizontal(classes="button-row"):
+                yield Button("Login", id="login-btn", variant="primary")
+                yield Button("Logout", id="logout-btn", variant="warning")
+
         # Tmux settings section
         with Static(classes="tmux-settings"):
             yield Static("[bold]Tmux Settings[/bold]", classes="section-title")
@@ -112,9 +154,15 @@ class ConfigPanel(Static):
         # Load initial data
         self.refresh_data()
 
+        # Update account status display
+        self._update_account_status()
+
         # Query and set the actual tmux border resize state
         self._sync_border_resize_switch()
 
+        # Start timer to periodically refresh account status (every 5 seconds)
+        self._refresh_timer = self.set_interval(5.0, self._update_account_status)
+
     def on_data_table_row_selected(self, event: DataTable.RowSelected) -> None:
         """Handle row selection in the config table."""
         table = self.query_one("#config-table", DataTable)
@@ -147,7 +195,12 @@ class ConfigPanel(Static):
             self._save_config()
         elif event.button.id == "reload-btn":
             self.refresh_data()
+            self._update_account_status()
             self.app.notify("Configuration reloaded", title="Config")
+        elif event.button.id == "login-btn":
+            self._handle_login()
+        elif event.button.id == "logout-btn":
+            self._handle_logout()
 
     def on_switch_changed(self, event: Switch.Changed) -> None:
         """Handle switch toggle events."""
@@ -156,6 +209,129 @@ class ConfigPanel(Static):
         if event.switch.id == "border-resize-switch":
             self._toggle_border_resize(event.value)
 
+    def _update_account_status(self) -> None:
+        """Update the account status display."""
+        try:
+            status_widget = self.query_one("#account-status", Static)
+            login_btn = self.query_one("#login-btn", Button)
+            logout_btn = self.query_one("#logout-btn", Button)
+        except Exception:
+            # Widget not ready yet
+            return
+
+        # Don't update if login is in progress
+        if self._login_in_progress:
+            return
+
+        credentials = get_current_user()
+        if credentials:
+            status_widget.update(
+                f"[green]Logged in as:[/green] [bold]{credentials.email}[/bold]"
+            )
+            login_btn.disabled = True
+            logout_btn.disabled = False
+        else:
+            status_widget.update("[yellow]Not logged in[/yellow]")
+            login_btn.disabled = False
+            logout_btn.disabled = True
+
+    def _handle_login(self) -> None:
+        """Handle login button click - start login flow in background."""
+        if self._login_in_progress:
+            self.app.notify("Login already in progress...", title="Login")
+            return
+
+        self._login_in_progress = True
+
+        # Update UI to show login in progress
+        login_btn = self.query_one("#login-btn", Button)
+        login_btn.disabled = True
+        status_widget = self.query_one("#account-status", Static)
+        status_widget.update("[cyan]Opening browser for login...[/cyan]")
+
+        # Start login flow in background thread
+        def do_login():
+            try:
+                port = find_free_port()
+                open_login_page(callback_port=port)
+
+                # Wait for callback (up to 5 minutes)
+                cli_token, error = start_callback_server(port, timeout=300)
+
+                if error:
+                    self.app.call_from_thread(
+                        self.app.notify, f"Login failed: {error}", title="Login", severity="error"
+                    )
+                    self.app.call_from_thread(self._update_account_status)
+                    return
+
+                if not cli_token:
+                    self.app.call_from_thread(
+                        self.app.notify, "No token received", title="Login", severity="error"
+                    )
+                    self.app.call_from_thread(self._update_account_status)
+                    return
+
+                # Validate token
+                credentials = validate_cli_token(cli_token)
+                if not credentials:
+                    self.app.call_from_thread(
+                        self.app.notify, "Invalid token", title="Login", severity="error"
+                    )
+                    self.app.call_from_thread(self._update_account_status)
+                    return
+
+                # Save credentials
+                if save_credentials(credentials):
+                    # Sync Supabase uid to local config
+                    try:
+                        config = ReAlignConfig.load()
+                        old_uid = config.uid
+                        config.uid = credentials.user_id
+                        if not config.user_name:
+                            config.user_name = credentials.email.split("@")[0]
+                        config.save()
+                        logger.info(f"Synced Supabase uid to config: {credentials.user_id[:8]}...")
+
+                        # V18: Upsert user info to users table
+                        try:
+                            from ...db import get_database
+                            db = get_database()
+                            db.upsert_user(config.uid, config.user_name)
+                        except Exception as e:
+                            logger.debug(f"Failed to upsert user to users table: {e}")
+                    except Exception as e:
+                        logger.warning(f"Failed to sync uid to config: {e}")
+
+                    self.app.call_from_thread(
+                        self.app.notify, f"Logged in as {credentials.email}", title="Login"
+                    )
+                else:
+                    self.app.call_from_thread(
+                        self.app.notify, "Failed to save credentials", title="Login", severity="error"
+                    )
+
+                self.app.call_from_thread(self._update_account_status)
+
+            finally:
+                self._login_in_progress = False
+
+        thread = threading.Thread(target=do_login, daemon=True)
+        thread.start()
+
+        self.app.notify("Complete login in browser...", title="Login")
+
+    def _handle_logout(self) -> None:
+        """Handle logout button click - clear credentials."""
+        credentials = load_credentials()
+        email = credentials.email if credentials else "user"
+
+        if clear_credentials():
+            self._update_account_status()
+            self.app.notify(f"Logged out: {email}", title="Account")
+        else:
+            self.app.notify("Failed to logout", title="Account", severity="error")
+
     def _sync_border_resize_switch(self) -> None:
         """Query tmux state and sync the switch to match."""
         try:

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,

realign/db/base.py

@@ -49,9 +49,9 @@ class SessionRecord:
     summary_status: Optional[str] = None
     summary_locked_until: Optional[datetime] = None
     summary_error: Optional[str] = None
-    # V9: creator information
-    creator_name: Optional[str] = None
-    creator_id: Optional[str] = None
+    # V18: user identity
+    created_by: Optional[str] = None  # Creator UID
+    shared_by: Optional[str] = None  # Sharer UID (who imported this)
     temp_title: Optional[str] = None
     # V10: cached total turn count for session list performance
     total_turns: Optional[int] = None
@@ -78,9 +78,6 @@ class TurnRecord:
     git_commit_hash: Optional[str] = None
     # V12: temporary title stored in DB turns.temp_title
     temp_title: Optional[str] = None
-    # V9: creator information
-    creator_name: Optional[str] = None
-    creator_id: Optional[str] = None
 
 
 @dataclass
@@ -102,9 +99,9 @@ class EventRecord:
     share_id: Optional[str] = None  # V14: Share ID on server (for reuse)
     share_admin_token: Optional[str] = None  # V14: Admin token for extending expiry
     share_expiry_at: Optional[datetime] = None  # V14: Last known expiry timestamp
-    # V9: creator information
-    creator_name: Optional[str] = None
-    creator_id: Optional[str] = None
+    # V18: user identity
+    created_by: Optional[str] = None  # Creator UID
+    shared_by: Optional[str] = None  # Sharer UID (who imported this)
 
 
 @dataclass
@@ -124,8 +121,8 @@ class AgentRecord:
     status: str = "active"  # 'active', 'stopped'
     attention: Optional[str] = None  # 'permission_request', 'stop', or None
     source: Optional[str] = None
-    creator_name: Optional[str] = None
-    creator_id: Optional[str] = None
+    # V18: user identity
+    created_by: Optional[str] = None  # Creator UID
 
 
 @dataclass
@@ -143,6 +140,16 @@ class AgentContextRecord:
     event_ids: Optional[List[str]] = None
 
 
+@dataclass
+class UserRecord:
+    """Represents a user in the users table (V18)."""
+
+    uid: str
+    user_name: Optional[str] = None
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+
+
 class DatabaseInterface(ABC):
     """Abstract interface for ReAlign storage backend."""
 
@@ -420,3 +427,13 @@ class DatabaseInterface(ABC):
     def get_all_locks(self, include_expired: bool = False) -> List[LockRecord]:
         """Get all locks, optionally including expired ones."""
         pass
+
+    @abstractmethod
+    def upsert_user(self, uid: str, user_name: Optional[str] = None) -> None:
+        """Insert or update a user in the users table (V18)."""
+        pass
+
+    @abstractmethod
+    def get_user(self, uid: str) -> Optional[UserRecord]:
+        """Get a user by UID from the users table (V18)."""
+        pass