aline-ai 0.6.6__py3-none-any.whl → 0.7.0__py3-none-any.whl

realign/dashboard/widgets/agents_panel.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import json as _json
 import re
 import shlex
 from pathlib import Path
@@ -163,9 +164,12 @@ class AgentsPanel(Container, can_focus=True):
         super().__init__()
         self._refresh_lock = asyncio.Lock()
         self._agents: list[dict] = []
+        self._rendered_fingerprint: str = ""
         self._refresh_worker: Optional[Worker] = None
         self._share_worker: Optional[Worker] = None
+        self._sync_worker: Optional[Worker] = None
         self._share_agent_id: Optional[str] = None
+        self._sync_agent_id: Optional[str] = None
         self._refresh_timer = None
 
     def compose(self) -> ComposeResult:
@@ -176,7 +180,7 @@ class AgentsPanel(Container, can_focus=True):
 
     def on_show(self) -> None:
         if self._refresh_timer is None:
-            self._refresh_timer = self.set_interval(30.0, self._on_refresh_timer)
+            self._refresh_timer = self.set_interval(1.0, self._on_refresh_timer)
         else:
             try:
                 self._refresh_timer.resume()
@@ -216,18 +220,27 @@ class AgentsPanel(Container, can_focus=True):
             agent_infos = db.list_agent_info()
             active_terminals = db.list_agents(status="active", limit=1000)
 
-            # Get tmux windows to retrieve session_id (same as Terminal panel)
+            # Latest window links per terminal (V23)
+            latest_links = db.list_latest_window_links(limit=2000)
+            link_by_terminal = {l.terminal_id: l for l in latest_links if l.terminal_id}
+
+            # Get tmux windows to retrieve window id and fallback session_id
             tmux_windows = tmux_manager.list_inner_windows()
-            # Map terminal_id -> tmux window
             terminal_to_window = {
                 w.terminal_id: w for w in tmux_windows if w.terminal_id
             }
 
-            # Collect all session_ids from tmux windows for title lookup
-            session_ids = [
-                w.session_id for w in tmux_windows if w.session_id and w.terminal_id
-            ]
-            # Fetch titles from database (same method as Terminal panel)
+            # Collect all session_ids for title lookup
+            session_ids: list[str] = []
+            for t in active_terminals:
+                link = link_by_terminal.get(t.id)
+                if link and link.session_id:
+                    session_ids.append(link.session_id)
+                    continue
+                window = terminal_to_window.get(t.id)
+                if window and window.session_id:
+                    session_ids.append(window.session_id)
+
             titles = self._fetch_session_titles(session_ids)
 
             # Map agent_info.id -> list of terminals
@@ -236,16 +249,21 @@ class AgentsPanel(Container, can_focus=True):
                 # Find which agent_info this terminal belongs to
                 agent_info_id = None
 
+                link = link_by_terminal.get(t.id)
+
                 # Method 1: Check source field for "agent:{agent_info_id}" format
                 source = t.source or ""
                 if source.startswith("agent:"):
-                    agent_info_id = source[6:]  # Extract agent_info_id after "agent:"
+                    agent_info_id = source[6:]
+
+                # Method 2: WindowLink agent_id
+                if not agent_info_id and link and link.agent_id:
+                    agent_info_id = link.agent_id
 
-                # Method 2: Fallback - check tmux window's session.agent_id
+                # Method 3: Fallback - check tmux window's session.agent_id
                 if not agent_info_id:
                     window = terminal_to_window.get(t.id)
                     if window and window.session_id:
-                        # Look up session to get agent_id
                         session = db.get_session_by_id(window.session_id)
                         if session:
                             agent_info_id = session.agent_id
@@ -254,16 +272,18 @@ class AgentsPanel(Container, can_focus=True):
                     if agent_info_id not in agent_to_terminals:
                         agent_to_terminals[agent_info_id] = []
 
-                    # Get session_id and title from tmux window (same as Terminal panel)
+                    # Get session_id from windowlink (preferred) or tmux window
                     window = terminal_to_window.get(t.id)
-                    session_id = window.session_id if window else None
+                    session_id = (
+                        link.session_id if link and link.session_id else (window.session_id if window else None)
+                    )
                     title = titles.get(session_id, "") if session_id else ""
 
                     agent_to_terminals[agent_info_id].append(
                         {
                             "terminal_id": t.id,
                             "session_id": session_id,
-                            "provider": t.provider or "",
+                            "provider": link.provider if link and link.provider else (t.provider or ""),
                             "session_type": t.session_type or "",
                             "title": title,
                             "cwd": t.cwd or "",
@@ -278,12 +298,23 @@ class AgentsPanel(Container, can_focus=True):
                         "name": info.name,
                         "description": info.description or "",
                         "terminals": terminals,
+                        "share_url": getattr(info, "share_url", None),
+                        "last_synced_at": getattr(info, "last_synced_at", None),
                     }
                 )
         except Exception as e:
             logger.debug(f"Failed to collect agents: {e}")
         return agents
 
+
+    @staticmethod
+    def _fingerprint(agents: list[dict]) -> str:
+        """Fast serialisation used only for change detection."""
+        try:
+            return _json.dumps(agents, sort_keys=True, default=str)
+        except Exception:
+            return ""
+
     def on_worker_state_changed(self, event: Worker.StateChanged) -> None:
         # Handle refresh worker
         if self._refresh_worker is not None and event.worker is self._refresh_worker:
@@ -293,6 +324,10 @@ class AgentsPanel(Container, can_focus=True):
                 self._agents = self._refresh_worker.result or []
             else:
                 return
+            fp = self._fingerprint(self._agents)
+            if fp == self._rendered_fingerprint:
+                return  # nothing changed – skip re-render to avoid flicker
+            self._rendered_fingerprint = fp
             self.run_worker(
                 self._render_agents(), group="agents-render", exclusive=True
             )
@@ -302,6 +337,10 @@ class AgentsPanel(Container, can_focus=True):
         if self._share_worker is not None and event.worker is self._share_worker:
             self._handle_share_worker_state_changed(event)
 
+        # Handle sync worker
+        if self._sync_worker is not None and event.worker is self._sync_worker:
+            self._handle_sync_worker_state_changed(event)
+
     async def _render_agents(self) -> None:
         async with self._refresh_lock:
             try:
@@ -339,15 +378,25 @@ class AgentsPanel(Container, can_focus=True):
                     )
                 )
 
-                # Share button
-                await row.mount(
-                    Button(
-                        "Share",
-                        id=f"share-{safe_id}",
-                        name=agent["id"],
-                        classes="agent-share",
+                # Share or Sync button (Sync if agent already has a share_url)
+                if agent.get("share_url"):
+                    await row.mount(
+                        Button(
+                            "Sync",
+                            id=f"sync-{safe_id}",
+                            name=agent["id"],
+                            classes="agent-share",
+                        )
+                    )
+                else:
+                    await row.mount(
+                        Button(
+                            "Share",
+                            id=f"share-{safe_id}",
+                            name=agent["id"],
+                            classes="agent-share",
+                        )
                     )
-                )
 
                 # Create terminal button
                 await row.mount(
@@ -500,6 +549,11 @@ class AgentsPanel(Container, can_focus=True):
             await self._share_agent(agent_id)
             return
 
+        if btn_id.startswith("sync-"):
+            agent_id = event.button.name or ""
+            await self._sync_agent(agent_id)
+            return
+
         if btn_id.startswith("switch-"):
             terminal_id = event.button.name or ""
             await self._switch_to_terminal(terminal_id)
@@ -543,7 +597,13 @@ class AgentsPanel(Container, can_focus=True):
 
     def _on_create_result(self, result: dict | None) -> None:
         if result:
-            self.app.notify(f"Created: {result.get('name')}", title="Agent")
+            if result.get("imported"):
+                n = result.get("sessions_imported", 0)
+                self.app.notify(
+                    f"Imported: {result.get('name')} ({n} sessions)", title="Agent"
+                )
+            else:
+                self.app.notify(f"Created: {result.get('name')}", title="Agent")
         self.refresh_data()
 
     async def _create_terminal_for_agent(self, agent_id: str) -> None:
@@ -619,7 +679,7 @@ class AgentsPanel(Container, can_focus=True):
         try:
             from ...codex_home import prepare_codex_home
 
-            codex_home = prepare_codex_home(terminal_id, agent_id=agent_id)
+            codex_home = prepare_codex_home(terminal_id)
         except Exception:
             codex_home = None
 
@@ -1127,3 +1187,76 @@ class AgentsPanel(Container, can_focus=True):
             self.app.notify(
                 f"Share failed (exit {exit_code}){suffix}", title="Share", timeout=6
             )
+
+    async def _sync_agent(self, agent_id: str) -> None:
+        """Sync all sessions for an agent with remote share."""
+        if not agent_id:
+            return
+
+        # Check if sync is already in progress
+        if self._sync_worker is not None and self._sync_worker.state in (
+            WorkerState.PENDING,
+            WorkerState.RUNNING,
+        ):
+            return
+
+        self._sync_agent_id = agent_id
+
+        app = self.app
+
+        def progress_callback(message: str) -> None:
+            try:
+                app.call_from_thread(app.notify, message, title="Sync", timeout=3)
+            except Exception:
+                pass
+
+        def work() -> dict:
+            from ...commands.sync_agent import sync_agent_command
+
+            return sync_agent_command(
+                agent_id=agent_id,
+                progress_callback=progress_callback,
+            )
+
+        self.app.notify("Starting sync...", title="Sync", timeout=2)
+        self._sync_worker = self.run_worker(work, thread=True, exit_on_error=False)
+
+    def _handle_sync_worker_state_changed(self, event: Worker.StateChanged) -> None:
+        """Handle sync worker state changes."""
+        if event.state == WorkerState.ERROR:
+            err = self._sync_worker.error if self._sync_worker else "Unknown error"
+            self.app.notify(f"Sync failed: {err}", title="Sync", severity="error")
+            return
+
+        if event.state != WorkerState.SUCCESS:
+            return
+
+        result = self._sync_worker.result if self._sync_worker else {}
+
+        if result.get("success"):
+            pulled = result.get("sessions_pulled", 0)
+            pushed = result.get("sessions_pushed", 0)
+
+            # Copy share URL to clipboard
+            agent_id = self._sync_agent_id
+            share_url = None
+            if agent_id:
+                agent = next((a for a in self._agents if a["id"] == agent_id), None)
+                if agent:
+                    share_url = agent.get("share_url")
+
+            if share_url:
+                copied = copy_text(self.app, share_url)
+                suffix = " (link copied)" if copied else ""
+            else:
+                suffix = ""
+
+            self.app.notify(
+                f"Synced: pulled {pulled}, pushed {pushed} session(s){suffix}",
+                title="Sync",
+                timeout=6,
+            )
+            self.refresh_data()
+        else:
+            error = result.get("error", "Unknown error")
+            self.app.notify(f"Sync failed: {error}", title="Sync", severity="error")

realign/db/base.py

@@ -129,7 +129,7 @@ class AgentRecord:
 
 @dataclass
 class AgentInfoRecord:
-    """Agent profile/identity data (V20)."""
+    """Agent profile/identity data (V20, V22: sync fields)."""
 
     id: str
     name: str
@@ -137,6 +137,27 @@ class AgentInfoRecord:
     updated_at: datetime
     description: Optional[str] = ""
     visibility: str = "visible"
+    # V22: sync metadata
+    share_id: Optional[str] = None
+    share_url: Optional[str] = None
+    share_admin_token: Optional[str] = None
+    share_contributor_token: Optional[str] = None
+    share_expiry_at: Optional[str] = None
+    last_synced_at: Optional[str] = None
+    sync_version: int = 0
+
+
+@dataclass
+class WindowLinkRecord:
+    """Represents a terminal/session association (V23)."""
+
+    terminal_id: str
+    agent_id: Optional[str] = None
+    session_id: Optional[str] = None
+    provider: Optional[str] = None
+    source: Optional[str] = None
+    ts: Optional[float] = None
+    created_at: Optional[datetime] = None
 
 
 @dataclass
@@ -228,6 +249,27 @@ class DatabaseInterface(ABC):
         """Backfill total_turns for all sessions from turns table (V10 migration)."""
         pass
 
+    @abstractmethod
+    def insert_window_link(
+        self,
+        *,
+        terminal_id: str,
+        agent_id: Optional[str],
+        session_id: Optional[str],
+        provider: Optional[str],
+        source: Optional[str],
+        ts: Optional[float] = None,
+    ) -> None:
+        """Insert a window link record (V23)."""
+        pass
+
+    @abstractmethod
+    def list_latest_window_links(
+        self, *, agent_id: Optional[str] = None, limit: int = 1000
+    ) -> List[WindowLinkRecord]:
+        """List latest window link per terminal (V23)."""
+        pass
+
     @abstractmethod
     def list_sessions(
         self, limit: int = 100, workspace_path: Optional[str] = None

realign/db/schema.py

@@ -82,9 +82,12 @@ Schema V19: Agent association for sessions.
 
 Schema V20: Agent identity/profile table.
 - agent_info table: name, description for agent profiles
+
+Schema V23: WindowLink mapping for terminal/session association.
+- windowlink table: terminal_id/agent_id/session_id with timestamp
 """
 
-SCHEMA_VERSION = 21
+SCHEMA_VERSION = 23
 
 FTS_EVENTS_SCRIPTS = [
     # Full Text Search for Events
@@ -343,13 +346,20 @@ INIT_SCRIPTS = [
         updated_at TEXT DEFAULT (datetime('now'))
     );
     """,
-    # Agent identity/profile table (V20)
+    # Agent identity/profile table (V20, V22: sync columns)
     """
     CREATE TABLE IF NOT EXISTS agent_info (
         id TEXT PRIMARY KEY,
         name TEXT NOT NULL,
         description TEXT DEFAULT '',
         visibility TEXT NOT NULL DEFAULT 'visible',
+        share_id TEXT,
+        share_url TEXT,
+        share_admin_token TEXT,
+        share_contributor_token TEXT,
+        share_expiry_at TEXT,
+        last_synced_at TEXT,
+        sync_version INTEGER DEFAULT 0,
         created_at TEXT DEFAULT (datetime('now')),
         updated_at TEXT DEFAULT (datetime('now'))
     );
@@ -405,6 +415,21 @@ MIGRATION_V1_TO_V2 = [
     """
     CREATE INDEX IF NOT EXISTS idx_sessions_type ON sessions(session_type);
     """,
+    # WindowLink table (V23)
+    """
+    CREATE TABLE IF NOT EXISTS windowlink (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        terminal_id TEXT NOT NULL,
+        agent_id TEXT,
+        session_id TEXT,
+        provider TEXT,
+        source TEXT,
+        ts REAL,
+        created_at TEXT DEFAULT (datetime('now'))
+    );
+    """,
+    "CREATE INDEX IF NOT EXISTS idx_windowlink_terminal_ts ON windowlink(terminal_id, ts DESC);",
+    "CREATE INDEX IF NOT EXISTS idx_windowlink_agent_ts ON windowlink(agent_id, ts DESC);",
 ]
 
 # Migration scripts from V2 to V3
@@ -693,6 +718,33 @@ MIGRATION_V20_TO_V21 = [
     "ALTER TABLE agent_info ADD COLUMN visibility TEXT NOT NULL DEFAULT 'visible';",
 ]
 
+MIGRATION_V21_TO_V22 = [
+    "ALTER TABLE agent_info ADD COLUMN share_id TEXT;",
+    "ALTER TABLE agent_info ADD COLUMN share_url TEXT;",
+    "ALTER TABLE agent_info ADD COLUMN share_admin_token TEXT;",
+    "ALTER TABLE agent_info ADD COLUMN share_contributor_token TEXT;",
+    "ALTER TABLE agent_info ADD COLUMN share_expiry_at TEXT;",
+    "ALTER TABLE agent_info ADD COLUMN last_synced_at TEXT;",
+    "ALTER TABLE agent_info ADD COLUMN sync_version INTEGER DEFAULT 0;",
+]
+
+MIGRATION_V22_TO_V23 = [
+    """
+    CREATE TABLE IF NOT EXISTS windowlink (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        terminal_id TEXT NOT NULL,
+        agent_id TEXT,
+        session_id TEXT,
+        provider TEXT,
+        source TEXT,
+        ts REAL,
+        created_at TEXT DEFAULT (datetime('now'))
+    );
+    """,
+    "CREATE INDEX IF NOT EXISTS idx_windowlink_terminal_ts ON windowlink(terminal_id, ts DESC);",
+    "CREATE INDEX IF NOT EXISTS idx_windowlink_agent_ts ON windowlink(agent_id, ts DESC);",
+]
+
 
 def get_migration_scripts(from_version: int, to_version: int) -> list:
     """Get migration scripts for upgrading between versions."""
@@ -767,4 +819,10 @@ def get_migration_scripts(from_version: int, to_version: int) -> list:
     if from_version < 21 and to_version >= 21:
         scripts.extend(MIGRATION_V20_TO_V21)
 
+    if from_version < 22 and to_version >= 22:
+        scripts.extend(MIGRATION_V21_TO_V22)
+
+    if from_version < 23 and to_version >= 23:
+        scripts.extend(MIGRATION_V22_TO_V23)
+
     return scripts

realign/db/sqlite_db.py

@@ -23,6 +23,7 @@ from .base import (
     AgentRecord,
     AgentInfoRecord,
     AgentContextRecord,
+    WindowLinkRecord,
     UserRecord,
 )
 from .schema import (
@@ -2395,6 +2396,92 @@ class SQLiteDatabase(DatabaseInterface):
         except sqlite3.OperationalError:
             return []
 
+    def insert_window_link(
+        self,
+        *,
+        terminal_id: str,
+        agent_id: Optional[str],
+        session_id: Optional[str],
+        provider: Optional[str],
+        source: Optional[str],
+        ts: Optional[float] = None,
+    ) -> None:
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        ts_value = ts if ts is not None else time.time()
+        try:
+            cursor.execute(
+                """
+                INSERT INTO windowlink (
+                    terminal_id, agent_id, session_id, provider, source, ts
+                ) VALUES (?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    terminal_id,
+                    agent_id,
+                    session_id,
+                    provider,
+                    source,
+                    float(ts_value),
+                ),
+            )
+            conn.commit()
+        except sqlite3.OperationalError:
+            conn.rollback()
+
+    def list_latest_window_links(
+        self, *, agent_id: Optional[str] = None, limit: int = 1000
+    ) -> List[WindowLinkRecord]:
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        params: List[Any] = []
+        where_clause = ""
+        if agent_id:
+            where_clause = "WHERE agent_id = ?"
+            params.append(agent_id)
+        params.append(limit)
+        try:
+            cursor.execute(
+                f"""
+                SELECT terminal_id, agent_id, session_id, provider, source, ts, created_at
+                FROM (
+                    SELECT terminal_id,
+                           agent_id,
+                           session_id,
+                           provider,
+                           source,
+                           ts,
+                           created_at,
+                           ROW_NUMBER() OVER (
+                               PARTITION BY terminal_id
+                               ORDER BY ts DESC, id DESC
+                           ) AS rn
+                    FROM windowlink
+                    {where_clause}
+                ) AS ranked
+                WHERE rn = 1
+                LIMIT ?
+                """,
+                params,
+            )
+            rows = cursor.fetchall()
+            out: List[WindowLinkRecord] = []
+            for row in rows:
+                out.append(
+                    WindowLinkRecord(
+                        terminal_id=row[0],
+                        agent_id=row[1],
+                        session_id=row[2],
+                        provider=row[3],
+                        source=row[4],
+                        ts=row[5],
+                        created_at=self._parse_datetime(row[6]) if row[6] else None,
+                    )
+                )
+            return out
+        except sqlite3.OperationalError:
+            return []
+
     def delete_agent(self, agent_id: str) -> bool:
         """Delete an agent by ID."""
         conn = self._get_connection()
@@ -3081,12 +3168,20 @@ class SQLiteDatabase(DatabaseInterface):
 
     def _row_to_agent_info(self, row: sqlite3.Row) -> AgentInfoRecord:
         """Convert a database row to an AgentInfoRecord."""
+        keys = row.keys()
         visibility = "visible"
         try:
-            if "visibility" in row.keys():
+            if "visibility" in keys:
                 visibility = row["visibility"] or "visible"
         except Exception:
             visibility = "visible"
+
+        def _safe_get(key: str, default=None):
+            try:
+                return row[key] if key in keys else default
+            except Exception:
+                return default
+
         return AgentInfoRecord(
             id=row["id"],
             name=row["name"],
@@ -3094,6 +3189,13 @@ class SQLiteDatabase(DatabaseInterface):
             created_at=self._parse_datetime(row["created_at"]),
             updated_at=self._parse_datetime(row["updated_at"]),
             visibility=visibility,
+            share_id=_safe_get("share_id"),
+            share_url=_safe_get("share_url"),
+            share_admin_token=_safe_get("share_admin_token"),
+            share_contributor_token=_safe_get("share_contributor_token"),
+            share_expiry_at=_safe_get("share_expiry_at"),
+            last_synced_at=_safe_get("last_synced_at"),
+            sync_version=_safe_get("sync_version", 0) or 0,
         )
 
     def get_or_create_agent_info(
@@ -3198,3 +3300,76 @@ class SQLiteDatabase(DatabaseInterface):
             return [self._row_to_agent_info(row) for row in cursor.fetchall()]
         except sqlite3.OperationalError:
             return []
+
+    def update_agent_sync_metadata(
+        self,
+        agent_id: str,
+        *,
+        share_id: Optional[str] = None,
+        share_url: Optional[str] = None,
+        share_admin_token: Optional[str] = None,
+        share_contributor_token: Optional[str] = None,
+        share_expiry_at: Optional[str] = None,
+        last_synced_at: Optional[str] = None,
+        sync_version: Optional[int] = None,
+    ) -> Optional[AgentInfoRecord]:
+        """Update sync-related metadata on an agent_info record."""
+        conn = self._get_connection()
+        sets: list[str] = []
+        params: list[Any] = []
+
+        if share_id is not None:
+            sets.append("share_id = ?")
+            params.append(share_id)
+        if share_url is not None:
+            sets.append("share_url = ?")
+            params.append(share_url)
+        if share_admin_token is not None:
+            sets.append("share_admin_token = ?")
+            params.append(share_admin_token)
+        if share_contributor_token is not None:
+            sets.append("share_contributor_token = ?")
+            params.append(share_contributor_token)
+        if share_expiry_at is not None:
+            sets.append("share_expiry_at = ?")
+            params.append(share_expiry_at)
+        if last_synced_at is not None:
+            sets.append("last_synced_at = ?")
+            params.append(last_synced_at)
+        if sync_version is not None:
+            sets.append("sync_version = ?")
+            params.append(sync_version)
+
+        if not sets:
+            return self.get_agent_info(agent_id)
+
+        sets.append("updated_at = datetime('now')")
+        params.append(agent_id)
+
+        try:
+            conn.execute(
+                f"UPDATE agent_info SET {', '.join(sets)} WHERE id = ?",
+                params,
+            )
+            conn.commit()
+        except sqlite3.OperationalError:
+            return None
+
+        return self.get_agent_info(agent_id)
+
+    def get_agent_content_hashes(self, agent_id: str) -> set[str]:
+        """Return all content_hash values for turns in this agent's sessions."""
+        conn = self._get_connection()
+        try:
+            cursor = conn.execute(
+                """
+                SELECT DISTINCT t.content_hash
+                FROM turns t
+                JOIN sessions s ON t.session_id = s.id
+                WHERE s.agent_id = ?
+                """,
+                (agent_id,),
+            )
+            return {row["content_hash"] for row in cursor.fetchall()}
+        except sqlite3.OperationalError:
+            return set()