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

realign/commands/search.py

@@ -335,9 +335,28 @@ def search_command(
             context_session_ids = get_context_session_ids()
             context_event_ids = get_context_event_ids()
 
+        # Apply agent scoping if ALINE_AGENT_ID is set
+        agent_session_ids = None
+        if not no_context:
+            import os
+
+            agent_id = os.environ.get("ALINE_AGENT_ID")
+            if agent_id:
+                agent_sessions = db.get_sessions_by_agent_id(agent_id)
+                # Always set agent_session_ids when agent_id exists
+                # (empty list means no sessions for this agent -> empty results)
+                agent_session_ids = [s.id for s in agent_sessions]
+
         # Parse session IDs if provided (resolve prefixes)
         session_ids = _resolve_id_prefixes(db, "sessions", sessions) or None
 
+        # Intersect with agent sessions first (highest priority)
+        if agent_session_ids is not None:
+            if session_ids:
+                session_ids = list(set(session_ids) & set(agent_session_ids))
+            else:
+                session_ids = agent_session_ids if agent_session_ids else []
+
         # Intersect with context sessions
         if context_session_ids:
             if session_ids:
@@ -372,43 +391,53 @@ def search_command(
         turn_ids = _resolve_id_prefixes(db, "turns", turns) or None
 
         # 1. Search Events (events don't have session scope, skip if sessions/events filter is active)
-        if type in ("all", "event") and not session_ids and not event_ids:
+        # Use 'is None' to distinguish "no filter" from "empty filter results"
+        if type in ("all", "event") and session_ids is None and event_ids is None:
             events = db.search_events(query, limit=limit, use_regex=regex, ignore_case=ignore_case)
             results["events"] = events
 
-        # 2. Search Turns
+        # 2. Search Turns (skip if session filter results in empty list)
         if type in ("all", "turn"):
-            turns = db.search_conversations(
-                query,
-                limit=limit,
-                use_regex=regex,
-                ignore_case=ignore_case,
-                session_ids=session_ids,
-            )
-            results["turns"] = turns
+            if session_ids is not None and len(session_ids) == 0:
+                results["turns"] = []
+            else:
+                turns = db.search_conversations(
+                    query,
+                    limit=limit,
+                    use_regex=regex,
+                    ignore_case=ignore_case,
+                    session_ids=session_ids if session_ids else None,
+                )
+                results["turns"] = turns
 
-        # 3. Search Sessions
+        # 3. Search Sessions (skip if session filter results in empty list)
         if type in ("all", "session"):
-            sessions_results = db.search_sessions(
-                query,
-                limit=limit,
-                use_regex=regex,
-                ignore_case=ignore_case,
-                session_ids=session_ids,
-            )
-            results["sessions"] = sessions_results
+            if session_ids is not None and len(session_ids) == 0:
+                results["sessions"] = []
+            else:
+                sessions_results = db.search_sessions(
+                    query,
+                    limit=limit,
+                    use_regex=regex,
+                    ignore_case=ignore_case,
+                    session_ids=session_ids if session_ids else None,
+                )
+                results["sessions"] = sessions_results
 
-        # 4. Search Turn Content
+        # 4. Search Turn Content (skip if session filter results in empty list)
         if type == "content":
-            content_results = db.search_turn_content(
-                query,
-                limit=limit,
-                use_regex=regex,
-                ignore_case=ignore_case,
-                session_ids=session_ids,
-                turn_ids=turn_ids,
-            )
-            results["content"] = content_results
+            if session_ids is not None and len(session_ids) == 0:
+                results["content"] = []
+            else:
+                content_results = db.search_turn_content(
+                    query,
+                    limit=limit,
+                    use_regex=regex,
+                    ignore_case=ignore_case,
+                    session_ids=session_ids if session_ids else None,
+                    turn_ids=turn_ids,
+                )
+                results["content"] = content_results
 
         # === Grep-style output for regex mode ===
         if regex:

realign/commands/sync_agent.py

@@ -0,0 +1,347 @@
+#!/usr/bin/env python3
+"""
+Sync agent command - Bidirectional sync for shared agents.
+
+Pull remote sessions, merge locally (union of sessions, dedup by content_hash),
+push merged result back. Uses optimistic locking via sync_version.
+
+Sync works with unencrypted shares only.
+"""
+
+import json
+import os
+import logging
+from datetime import datetime, timezone
+from typing import Optional, Dict, Any, Callable
+
+try:
+    import httpx
+
+    HTTPX_AVAILABLE = True
+except ImportError:
+    HTTPX_AVAILABLE = False
+
+from ..logging_config import setup_logger
+
+logger = setup_logger("realign.commands.sync_agent", "sync_agent.log")
+
+MAX_SYNC_RETRIES = 3
+
+
+def sync_agent_command(
+    agent_id: str,
+    backend_url: Optional[str] = None,
+    progress_callback: Optional[Callable[[str], None]] = None,
+) -> dict:
+    """
+    Sync an agent's sessions with the remote share.
+
+    Algorithm:
+    1. Load local state (agent_info, sessions, content hashes)
+    2. Pull remote state (full download via export endpoint)
+    3. Merge: union of sessions deduped by content_hash, last-write-wins for name/desc
+    4. Push merged state via PUT with optimistic locking
+    5. Update local sync metadata
+
+    Args:
+        agent_id: The agent_info ID to sync
+        backend_url: Backend server URL (uses config default if None)
+        progress_callback: Optional callback for progress updates
+
+    Returns:
+        {"success": True, "sessions_pulled": N, "sessions_pushed": N, ...} on success
+        {"success": False, "error": str} on failure
+    """
+    def _progress(msg: str) -> None:
+        if progress_callback:
+            progress_callback(msg)
+
+    if not HTTPX_AVAILABLE:
+        return {"success": False, "error": "httpx package not installed"}
+
+    # Get backend URL
+    if backend_url is None:
+        from ..config import ReAlignConfig
+
+        config = ReAlignConfig.load()
+        backend_url = config.share_backend_url or "https://realign-server.vercel.app"
+
+    # Get database
+    from ..db import get_database
+
+    db = get_database()
+
+    # 1. Load local state
+    _progress("Loading local agent data...")
+
+    agent_info = db.get_agent_info(agent_id)
+    if not agent_info:
+        return {"success": False, "error": f"Agent not found: {agent_id}"}
+
+    if not agent_info.share_id or not agent_info.share_url:
+        return {"success": False, "error": "Agent has no share metadata (not shared yet)"}
+
+    token = agent_info.share_admin_token or agent_info.share_contributor_token
+    if not token:
+        return {"success": False, "error": "No token available for sync (need admin or contributor token)"}
+
+    share_id = agent_info.share_id
+    local_sync_version = agent_info.sync_version or 0
+
+    local_sessions = db.get_sessions_by_agent_id(agent_id)
+    local_content_hashes = db.get_agent_content_hashes(agent_id)
+
+    logger.info(
+        f"Sync: agent={agent_id}, share={share_id}, "
+        f"local_sessions={len(local_sessions)}, local_hashes={len(local_content_hashes)}"
+    )
+
+    # 2. Pull remote state
+    _progress("Pulling remote data...")
+
+    remote_data = _pull_remote(backend_url, share_id)
+    if not remote_data.get("success"):
+        return {"success": False, "error": f"Failed to pull remote: {remote_data.get('error')}"}
+
+    conversation_data = remote_data["data"]
+    remote_sync_meta = conversation_data.get("sync_metadata", {})
+    remote_sync_version = remote_sync_meta.get("sync_version", 0)
+
+    remote_sessions_data = conversation_data.get("sessions", [])
+    remote_event = conversation_data.get("event", {})
+
+    # 3. Merge
+    _progress("Merging sessions...")
+
+    # Collect remote content hashes
+    remote_content_hashes = set()
+    for session_data in remote_sessions_data:
+        for turn_data in session_data.get("turns", []):
+            h = turn_data.get("content_hash")
+            if h:
+                remote_content_hashes.add(h)
+
+    # Import new remote sessions/turns locally
+    sessions_pulled = 0
+    from .import_shares import import_session_with_turns
+
+    for session_data in remote_sessions_data:
+        session_id = session_data.get("session_id", "")
+        session_turns = session_data.get("turns", [])
+
+        # Check if any turns in this session are new to us
+        new_turns = [
+            t for t in session_turns
+            if t.get("content_hash") and t["content_hash"] not in local_content_hashes
+        ]
+
+        if not new_turns:
+            continue
+
+        # Import the session (import_session_with_turns handles dedup by content_hash)
+        try:
+            # Suppress auto-summaries during sync
+            os.environ["REALIGN_DISABLE_AUTO_SUMMARIES"] = "1"
+            import_result = import_session_with_turns(
+                session_data, f"agent-{agent_id}", agent_info.share_url, db, force=False
+            )
+            if import_result.get("sessions", 0) > 0 or import_result.get("turns", 0) > 0:
+                sessions_pulled += 1
+
+            # Link session to agent
+            db.update_session_agent_id(session_id, agent_id)
+        except Exception as e:
+            logger.error(f"Failed to import remote session {session_id}: {e}")
+
+    # Merge name/description: last-write-wins by updated_at
+    description_updated = False
+    remote_updated_at = remote_event.get("updated_at")
+    if remote_updated_at:
+        try:
+            remote_dt = datetime.fromisoformat(remote_updated_at.replace("Z", "+00:00"))
+            local_dt = agent_info.updated_at
+            if hasattr(local_dt, "tzinfo") and local_dt.tzinfo is None:
+                local_dt = local_dt.replace(tzinfo=timezone.utc)
+            if remote_dt > local_dt:
+                remote_name = remote_event.get("title")
+                remote_desc = remote_event.get("description")
+                updates = {}
+                if remote_name and remote_name != agent_info.name:
+                    updates["name"] = remote_name
+                if remote_desc is not None and remote_desc != agent_info.description:
+                    updates["description"] = remote_desc
+                if updates:
+                    db.update_agent_info(agent_id, **updates)
+                    description_updated = True
+                    agent_info = db.get_agent_info(agent_id)
+        except Exception as e:
+            logger.warning(f"Failed to compare timestamps for name/desc merge: {e}")
+
+    # 4. Build merged data and push
+    _progress("Pushing merged data...")
+
+    # Reload local state after merge
+    local_sessions = db.get_sessions_by_agent_id(agent_id)
+    local_content_hashes = db.get_agent_content_hashes(agent_id)
+
+    # Count sessions pushed (local sessions with turns not in remote)
+    sessions_pushed = 0
+    for session in local_sessions:
+        turns = db.get_turns_for_session(session.id)
+        new_local_turns = [t for t in turns if t.content_hash not in remote_content_hashes]
+        if new_local_turns:
+            sessions_pushed += 1
+
+    # Build full conversation data for push
+    merged_conversation = _build_merged_conversation_data(
+        agent_info=agent_info,
+        agent_id=agent_id,
+        sessions=local_sessions,
+        db=db,
+        contributor_token=agent_info.share_contributor_token,
+    )
+
+    # Push with optimistic locking + retry
+    from .export_shares import _update_share_content
+
+    new_version = remote_sync_version
+    for attempt in range(MAX_SYNC_RETRIES):
+        try:
+            push_result = _update_share_content(
+                backend_url=backend_url,
+                share_id=share_id,
+                token=token,
+                conversation_data=merged_conversation,
+                expected_version=new_version,
+            )
+            new_version = push_result.get("version", new_version + 1)
+            break
+        except Exception as e:
+            error_str = str(e)
+            if "409" in error_str and attempt < MAX_SYNC_RETRIES - 1:
+                _progress(f"Version conflict, retrying ({attempt + 2}/{MAX_SYNC_RETRIES})...")
+                # Re-pull and retry
+                remote_data = _pull_remote(backend_url, share_id)
+                if remote_data.get("success"):
+                    conv = remote_data["data"]
+                    new_version = conv.get("sync_metadata", {}).get("sync_version", 0)
+                continue
+            else:
+                logger.error(f"Push failed after {attempt + 1} attempts: {e}")
+                return {"success": False, "error": f"Push failed: {e}"}
+
+    # 5. Update local sync metadata
+    now_iso = datetime.now(timezone.utc).isoformat()
+    db.update_agent_sync_metadata(
+        agent_id,
+        last_synced_at=now_iso,
+        sync_version=new_version,
+    )
+
+    _progress("Sync complete!")
+
+    return {
+        "success": True,
+        "sessions_pulled": sessions_pulled,
+        "sessions_pushed": sessions_pushed,
+        "description_updated": description_updated,
+        "new_sync_version": new_version,
+    }
+
+
+def _pull_remote(backend_url: str, share_id: str) -> dict:
+    """Pull remote share data via the download_share_data helper."""
+    try:
+        from .import_shares import download_share_data
+
+        share_url = f"{backend_url}/share/{share_id}"
+        return download_share_data(share_url, password=None)
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def _build_merged_conversation_data(
+    agent_info,
+    agent_id: str,
+    sessions,
+    db,
+    contributor_token: Optional[str] = None,
+) -> dict:
+    """
+    Build a full conversation data dict from local agent state.
+
+    Mirrors the structure of build_enhanced_conversation_data but works
+    directly from DB records without ExportableSession wrappers.
+    """
+    import json as json_module
+
+    event_data = {
+        "event_id": f"agent-{agent_id}",
+        "title": agent_info.name or "Agent Sessions",
+        "description": agent_info.description or "",
+        "event_type": "agent",
+        "status": "active",
+        "created_at": agent_info.created_at.isoformat() if agent_info.created_at else None,
+        "updated_at": agent_info.updated_at.isoformat() if agent_info.updated_at else None,
+    }
+
+    sessions_data = []
+    for session in sessions:
+        turns = db.get_turns_for_session(session.id)
+        turns_data = []
+        for turn in turns:
+            turn_content = db.get_turn_content(turn.id)
+            messages = []
+            if turn_content:
+                for line in turn_content.strip().split("\n"):
+                    if line.strip():
+                        try:
+                            messages.append(json_module.loads(line))
+                        except Exception:
+                            continue
+
+            turns_data.append({
+                "turn_id": turn.id,
+                "turn_number": turn.turn_number,
+                "content_hash": turn.content_hash,
+                "timestamp": turn.timestamp.isoformat() if turn.timestamp else None,
+                "llm_title": turn.llm_title or "",
+                "llm_description": turn.llm_description,
+                "user_message": turn.user_message,
+                "assistant_summary": turn.assistant_summary,
+                "model_name": turn.model_name,
+                "git_commit_hash": turn.git_commit_hash,
+                "messages": messages,
+            })
+
+        sessions_data.append({
+            "session_id": session.id,
+            "session_type": session.session_type or "unknown",
+            "workspace_path": session.workspace_path,
+            "session_title": session.session_title,
+            "session_summary": session.session_summary,
+            "started_at": session.started_at.isoformat() if session.started_at else None,
+            "last_activity_at": session.last_activity_at.isoformat() if session.last_activity_at else None,
+            "created_by": session.created_by,
+            "shared_by": session.shared_by,
+            "turns": turns_data,
+        })
+
+    username = os.environ.get("USER") or os.environ.get("USERNAME") or "anonymous"
+
+    result = {
+        "version": "2.1",
+        "username": username,
+        "time": datetime.now(timezone.utc).isoformat(),
+        "event": event_data,
+        "sessions": sessions_data,
+        "ui_metadata": {},
+    }
+
+    if contributor_token:
+        result["sync_metadata"] = {
+            "contributor_token": contributor_token,
+            "sync_version": agent_info.sync_version or 0,
+        }
+
+    return result

realign/dashboard/app.py

@@ -16,7 +16,7 @@ from .widgets import (
     WatcherPanel,
     WorkerPanel,
     ConfigPanel,
-    TerminalPanel,
+    AgentsPanel,
 )
 
 # Environment variable to control terminal mode
@@ -104,9 +104,9 @@ class AlineDashboard(App):
         try:
             yield AlineHeader()
             tab_ids = self._tab_ids()
-            with TabbedContent(initial=tab_ids[0] if tab_ids else "terminal"):
-                with TabPane("Agents", id="terminal"):
-                    yield TerminalPanel(use_native_terminal=self.use_native_terminal)
+            with TabbedContent(initial=tab_ids[0] if tab_ids else "agents"):
+                with TabPane("Agents", id="agents"):
+                    yield AgentsPanel()
                 if self.dev_mode:
                     with TabPane("Watcher", id="watcher"):
                         yield WatcherPanel()
@@ -122,8 +122,8 @@ class AlineDashboard(App):
 
     def _tab_ids(self) -> list[str]:
         if self.dev_mode:
-            return ["terminal", "watcher", "worker", "config"]
-        return ["terminal", "config"]
+            return ["agents", "watcher", "worker", "config"]
+        return ["agents", "config"]
 
     def on_mount(self) -> None:
         """Apply theme based on system settings and watch for changes."""
@@ -205,14 +205,14 @@ class AlineDashboard(App):
         tabbed_content = self.query_one(TabbedContent)
         active_tab_id = tabbed_content.active
 
-        if active_tab_id == "watcher":
+        if active_tab_id == "agents":
+            self.query_one(AgentsPanel).refresh_data()
+        elif active_tab_id == "watcher":
             self.query_one(WatcherPanel).refresh_data()
         elif active_tab_id == "worker":
             self.query_one(WorkerPanel).refresh_data()
         elif active_tab_id == "config":
             self.query_one(ConfigPanel).refresh_data()
-        elif active_tab_id == "terminal":
-            await self.query_one(TerminalPanel).refresh_data()
 
     def action_page_next(self) -> None:
         """Go to next page in current panel."""

realign/dashboard/clipboard.py

@@ -0,0 +1,54 @@
+"""Clipboard helpers for the dashboard."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+
+
+def _run_copy(command: list[str], text: str) -> bool:
+    try:
+        return (
+            subprocess.run(
+                command,
+                input=text,
+                text=True,
+                capture_output=False,
+                check=False,
+            ).returncode
+            == 0
+        )
+    except Exception:
+        return False
+
+
+def copy_text(app, text: str) -> bool:
+    if not text:
+        return False
+
+    if shutil.which("pbcopy"):
+        if _run_copy(["pbcopy"], text):
+            return True
+
+    if os.name == "nt" and shutil.which("clip"):
+        if _run_copy(["clip"], text):
+            return True
+
+    if shutil.which("wl-copy"):
+        if _run_copy(["wl-copy"], text):
+            return True
+
+    if shutil.which("xclip"):
+        if _run_copy(["xclip", "-selection", "clipboard"], text):
+            return True
+
+    if shutil.which("xsel"):
+        if _run_copy(["xsel", "--clipboard", "--input"], text):
+            return True
+
+    try:
+        app.copy_to_clipboard(text)
+        return True
+    except Exception:
+        return False

realign/dashboard/screens/__init__.py

@@ -2,16 +2,20 @@
 
 from .session_detail import SessionDetailScreen
 from .event_detail import EventDetailScreen
+from .agent_detail import AgentDetailScreen
 from .create_event import CreateEventScreen
 from .create_agent import CreateAgentScreen
+from .create_agent_info import CreateAgentInfoScreen
 from .share_import import ShareImportScreen
 from .help_screen import HelpScreen
 
 __all__ = [
     "SessionDetailScreen",
     "EventDetailScreen",
+    "AgentDetailScreen",
     "CreateEventScreen",
     "CreateAgentScreen",
+    "CreateAgentInfoScreen",
     "ShareImportScreen",
     "HelpScreen",
 ]