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

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()

realign/watcher_core.py

@@ -259,6 +259,54 @@ class DialogueWatcher:
         except Exception:
             return
 
+    def _agent_info_id_for_codex_session(
+        self, session_file: Path, *, db=None
+    ) -> Optional[str]:
+        """Best-effort: resolve agent_info_id from a codex session file."""
+        try:
+            from .codex_home import codex_home_owner_from_session_file
+        except Exception:
+            return None
+
+        try:
+            owner = codex_home_owner_from_session_file(session_file)
+        except Exception:
+            owner = None
+        if not owner or owner[0] != "terminal":
+            return None
+        terminal_id = owner[1]
+        if not terminal_id:
+            return None
+
+        try:
+            if db is None:
+                from .db import get_database
+
+                db = get_database(read_only=True)
+            agent = db.get_agent_by_id(terminal_id)
+        except Exception:
+            return None
+
+        source = (agent.source or "").strip() if agent else ""
+        if source.startswith("agent:"):
+            return source[6:]
+        return None
+
+    def _terminal_id_for_codex_session(self, session_file: Path) -> Optional[str]:
+        """Best-effort: resolve terminal_id from codex session file path."""
+        try:
+            from .codex_home import codex_home_owner_from_session_file
+        except Exception:
+            return None
+
+        try:
+            owner = codex_home_owner_from_session_file(session_file)
+        except Exception:
+            owner = None
+        if not owner or owner[0] != "terminal":
+            return None
+        return owner[1]
+
         try:
             from .codex_home import codex_home_owner_from_session_file
             from .codex_terminal_linker import read_codex_session_meta, select_agent_for_codex_session
@@ -326,6 +374,18 @@ class DialogueWatcher:
                 source=source,
             )
 
+            try:
+                db.insert_window_link(
+                    terminal_id=agent_id,
+                    agent_id=agent_info_id,
+                    session_id=session_file.stem,
+                    provider="codex",
+                    source="codex:watcher",
+                    ts=time.time(),
+                )
+            except Exception:
+                pass
+
             # Link session to agent_info if available (bidirectional linking)
             if agent_info_id:
                 try:
@@ -851,6 +911,23 @@ class DialogueWatcher:
                     file=sys.stderr,
                 )
 
+                agent_id = None
+                if session_type == "codex":
+                    agent_id = self._agent_info_id_for_codex_session(session_file, db=db)
+                    terminal_id = self._terminal_id_for_codex_session(session_file)
+                    if terminal_id:
+                        try:
+                            db.insert_window_link(
+                                terminal_id=terminal_id,
+                                agent_id=agent_id,
+                                session_id=session_id,
+                                provider="codex",
+                                source="codex:watcher",
+                                ts=time.time(),
+                            )
+                        except Exception:
+                            pass
+
                 enqueued = 0
                 for turn in missing_turns:
                     try:
@@ -859,6 +936,7 @@ class DialogueWatcher:
                             workspace_path=project_path,
                             turn_number=turn,
                             session_type=session_type,
+                            agent_id=agent_id if agent_id else None,
                         )
                         enqueued += 1
                     except Exception as e:
@@ -992,6 +1070,22 @@ class DialogueWatcher:
                             continue
 
                         enqueued_any = False
+                        agent_id = None
+                        if session_type == "codex":
+                            agent_id = self._agent_info_id_for_codex_session(session_file, db=db)
+                            terminal_id = self._terminal_id_for_codex_session(session_file)
+                            if terminal_id:
+                                try:
+                                    db.insert_window_link(
+                                        terminal_id=terminal_id,
+                                        agent_id=agent_id,
+                                        session_id=session_id,
+                                        provider="codex",
+                                        source="codex:watcher",
+                                        ts=time.time(),
+                                    )
+                                except Exception:
+                                    pass
                         for turn_number in sorted(set(new_turns)):
                             try:
                                 db.enqueue_turn_summary_job(  # type: ignore[attr-defined]
@@ -999,6 +1093,7 @@ class DialogueWatcher:
                                     workspace_path=project_path,
                                     turn_number=int(turn_number),
                                     session_type=session_type,
+                                    agent_id=agent_id if agent_id else None,
                                 )
                                 enqueued_any = True
                             except Exception as e:
@@ -1249,13 +1344,31 @@ class DialogueWatcher:
                     continue
 
                 enqueued_any = False
+                session_type = self._detect_session_type(session_file)
+                agent_id = None
+                if session_type == "codex":
+                    agent_id = self._agent_info_id_for_codex_session(session_file, db=db)
+                    terminal_id = self._terminal_id_for_codex_session(session_file)
+                    if terminal_id:
+                        try:
+                            db.insert_window_link(
+                                terminal_id=terminal_id,
+                                agent_id=agent_id,
+                                session_id=session_file.stem,
+                                provider="codex",
+                                source="codex:watcher",
+                                ts=time.time(),
+                            )
+                        except Exception:
+                            pass
                 for turn_number in new_turns:
                     try:
                         db.enqueue_turn_summary_job(  # type: ignore[attr-defined]
                             session_file_path=session_file,
                             workspace_path=project_path,
                             turn_number=turn_number,
-                            session_type=self._detect_session_type(session_file),
+                            session_type=session_type,
+                            agent_id=agent_id if agent_id else None,
                         )
                         enqueued_any = True
                     except Exception as e:
@@ -1305,11 +1418,29 @@ class DialogueWatcher:
 
                 for turn_number in new_turns:
                     try:
+                        session_type = self._detect_session_type(session_file)
+                        agent_id = None
+                        if session_type == "codex":
+                            agent_id = self._agent_info_id_for_codex_session(session_file, db=db)
+                            terminal_id = self._terminal_id_for_codex_session(session_file)
+                            if terminal_id:
+                                try:
+                                    db.insert_window_link(
+                                        terminal_id=terminal_id,
+                                        agent_id=agent_id,
+                                        session_id=session_file.stem,
+                                        provider="codex",
+                                        source="codex:watcher",
+                                        ts=time.time(),
+                                    )
+                                except Exception:
+                                    pass
                         db.enqueue_turn_summary_job(  # type: ignore[attr-defined]
                             session_file_path=session_file,
                             workspace_path=project_path,
                             turn_number=turn_number,
-                            session_type=self._detect_session_type(session_file),
+                            session_type=session_type,
+                            agent_id=agent_id if agent_id else None,
                         )
                     except Exception:
                         continue

realign/worker_core.py

@@ -224,9 +224,12 @@ class AlineWorker:
         )
 
         # Link session to agent after commit ensures session exists in DB
-        if agent_id and session_id:
+        if session_id:
             try:
-                self.db.update_session_agent_id(session_id, agent_id)
+                if agent_id:
+                    self.db.update_session_agent_id(session_id, agent_id)
+                else:
+                    self._maybe_link_session_from_terminal(session_id)
             except Exception:
                 pass
 
@@ -261,6 +264,38 @@ class AlineWorker:
         except Exception as e:
             logger.warning(f"Failed to enqueue session summary after import for {session_id}: {e}")
 
+    def _maybe_link_session_from_terminal(self, session_id: str) -> None:
+        """Best-effort: backfill sessions.agent_id using terminal mapping."""
+        try:
+            session = self.db.get_session_by_id(session_id)
+            if session and getattr(session, "agent_id", None):
+                return
+        except Exception:
+            return
+
+        try:
+            agents = self.db.list_agents(status=None, limit=1000)
+        except Exception:
+            return
+
+        agent_info_id = None
+        for agent in agents:
+            try:
+                if (agent.session_id or "").strip() != session_id:
+                    continue
+                source = (agent.source or "").strip()
+                if source.startswith("agent:"):
+                    agent_info_id = source[6:]
+                    break
+            except Exception:
+                continue
+
+        if agent_info_id:
+            try:
+                self.db.update_session_agent_id(session_id, agent_info_id)
+            except Exception:
+                pass
+
     async def _process_session_summary_job(self, payload: Dict[str, Any]) -> bool:
         session_id = str(payload.get("session_id") or "")
         if not session_id: