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

realign/commands/import_shares.py

@@ -44,6 +44,206 @@ else:
     console = None
 
 
+def download_share_data(
+    share_url: str,
+    password: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Download share data from a share URL.
+
+    Extracts download logic (URL parse, auth, fetch) into a reusable function.
+
+    Args:
+        share_url: Full share URL (e.g., https://realign-server.vercel.app/share/abc123)
+        password: Password for encrypted shares
+
+    Returns:
+        {"success": True, "data": conversation_data} on success
+        {"success": False, "error": str} on failure
+    """
+    if not HTTPX_AVAILABLE:
+        return {"success": False, "error": "httpx package not installed. Install with: pip install httpx"}
+
+    share_id = extract_share_id(share_url)
+    if not share_id:
+        return {"success": False, "error": f"Invalid share URL format: {share_url}"}
+
+    logger.info(f"download_share_data: share_id={share_id}")
+
+    config = ReAlignConfig.load()
+    backend_url = config.share_backend_url or "https://realign-server.vercel.app"
+
+    # Get share info
+    try:
+        info_response = httpx.get(f"{backend_url}/api/share/{share_id}/info", timeout=10.0)
+        info_response.raise_for_status()
+        info = info_response.json()
+    except Exception as e:
+        return {"success": False, "error": f"Failed to fetch share info: {e}"}
+
+    # Authenticate
+    if info.get("requires_password"):
+        if not password:
+            return {"success": False, "error": "This share requires a password"}
+        password_hash = hashlib.sha256(password.encode()).hexdigest()
+        headers = {"X-Password-Hash": password_hash}
+    else:
+        try:
+            session_response = httpx.post(
+                f"{backend_url}/api/share/{share_id}/session", timeout=10.0
+            )
+            session_response.raise_for_status()
+            session_data = session_response.json()
+            session_token = session_data.get("session_token")
+            headers = {"Authorization": f"Bearer {session_token}"}
+        except Exception as e:
+            return {"success": False, "error": f"Failed to create session: {e}"}
+
+    # Download export data
+    try:
+        export_response = httpx.get(
+            f"{backend_url}/api/share/{share_id}/export", headers=headers, timeout=30.0
+        )
+        export_data = export_response.json()
+
+        if export_response.status_code == 413 or export_data.get("needs_chunked_download"):
+            total_chunks = export_data.get("total_chunks", 1)
+            raw_data = _download_chunks(backend_url, share_id, headers, total_chunks)
+            conversation_data = json.loads(raw_data)
+            export_data = {
+                "success": True,
+                "data": conversation_data,
+                "metadata": export_data.get("metadata", {}),
+            }
+        else:
+            export_response.raise_for_status()
+    except Exception as e:
+        return {"success": False, "error": f"Failed to download data: {e}"}
+
+    if not export_data.get("success"):
+        return {"success": False, "error": export_data.get("error", "Unknown error")}
+
+    return {"success": True, "data": export_data["data"]}
+
+
+def import_agent_from_share(
+    share_url: str,
+    password: Optional[str] = None,
+    db: Optional[DatabaseInterface] = None,
+) -> Dict[str, Any]:
+    """
+    Import an agent from a share link.
+
+    Downloads share data, creates agent_info record, imports sessions with
+    created_by/shared_by tracking, and links them to the agent.
+
+    Args:
+        share_url: Full share URL
+        password: Password for encrypted shares
+        db: Database instance (auto-created if None)
+
+    Returns:
+        {"success": True, "agent_id", "agent_name", "agent_description",
+         "sessions_imported", "turns_imported"} on success
+        {"success": False, "error": str} on failure
+    """
+    os.environ["REALIGN_DISABLE_AUTO_SUMMARIES"] = "1"
+
+    result = download_share_data(share_url, password)
+    if not result["success"]:
+        return result
+
+    conversation_data = result["data"]
+
+    # Extract agent identity from share data
+    event_data = conversation_data.get("event", {})
+    event_id = event_data.get("event_id", "")
+
+    # Agent ID: strip "agent-" prefix if present, otherwise generate new UUID
+    if event_id.startswith("agent-"):
+        agent_id = event_id[6:]
+    else:
+        agent_id = str(uuid_lib.uuid4())
+
+    agent_name = event_data.get("title") or "Imported Agent"
+    agent_description = event_data.get("description") or ""
+
+    # Set up database
+    if db is None:
+        from ..db.sqlite_db import SQLiteDatabase
+
+        config = ReAlignConfig.load()
+        db_path = Path(config.sqlite_db_path).expanduser()
+        db = SQLiteDatabase(db_path=db_path)
+
+    # Create agent_info record
+    try:
+        db.get_or_create_agent_info(agent_id, name=agent_name)
+        if agent_description:
+            db.update_agent_info(agent_id, description=agent_description)
+    except Exception as e:
+        return {"success": False, "error": f"Failed to create agent info: {e}"}
+
+    # Import sessions and link to agent
+    sessions_data = conversation_data.get("sessions", [])
+    total_sessions = 0
+    total_turns = 0
+
+    for session_data in sessions_data:
+        session_id = session_data.get("session_id") or generate_uuid()
+
+        # Use existing import logic (handles created_by/shared_by)
+        try:
+            # Use a dummy event_id — we don't need event linkage for agent imports
+            import_result = import_session_with_turns(
+                session_data, event_id or agent_id, share_url, db, force=False
+            )
+            total_sessions += import_result["sessions"]
+            total_turns += import_result["turns"]
+        except Exception as e:
+            logger.error(f"Failed to import session {session_id}: {e}")
+            continue
+
+        # Link session to agent
+        try:
+            db.update_session_agent_id(session_id, agent_id)
+        except Exception as e:
+            logger.error(f"Failed to link session {session_id} to agent: {e}")
+
+    # Extract and store sync metadata (for unencrypted shares)
+    sync_meta = conversation_data.get("sync_metadata", {})
+    contributor_token = sync_meta.get("contributor_token")
+    sync_enabled = False
+
+    if contributor_token and not password:
+        sync_enabled = True
+        share_id = extract_share_id(share_url)
+        try:
+            db.update_agent_sync_metadata(
+                agent_id,
+                share_id=share_id,
+                share_url=share_url,
+                share_contributor_token=contributor_token,
+                # No admin_token for importers
+                last_synced_at=datetime.now().isoformat(),
+                sync_version=sync_meta.get("sync_version", 0),
+            )
+        except Exception as e:
+            logger.warning(f"Failed to store sync metadata: {e}")
+            sync_enabled = False
+
+    return {
+        "success": True,
+        "agent_id": agent_id,
+        "agent_name": agent_name,
+        "agent_description": agent_description,
+        "sessions_imported": total_sessions,
+        "turns_imported": total_turns,
+        "sync_enabled": sync_enabled,
+        "share_url": share_url if sync_enabled else None,
+    }
+
+
 def import_share_command(
     share_url: str,
     password: Optional[str] = None,
@@ -84,11 +284,13 @@ def import_share_command(
 
     logger.info(f"Extracted share_id: {share_id}")
 
-    # 2. Get share info
+    # Use download_share_data helper for non-interactive password case
+    # For interactive mode, we still need the prompt flow
     config = ReAlignConfig.load()
     backend_url = config.share_backend_url or "https://realign-server.vercel.app"
     logger.info(f"Backend URL: {backend_url}")
 
+    # 2. Get share info and handle password prompt interactively
     try:
         if console:
             console.print(f"[cyan]Fetching share info from {backend_url}...[/cyan]")

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

@@ -13,8 +13,6 @@ from textual.widgets import Footer, TabbedContent, TabPane
 from ..logging_config import setup_logger
 from .widgets import (
     AlineHeader,
-    WatcherPanel,
-    WorkerPanel,
     ConfigPanel,
     AgentsPanel,
 )
@@ -64,30 +62,24 @@ class AlineDashboard(App):
         Binding("?", "help", "Help"),
         Binding("tab", "next_tab", "Next Tab", priority=True, show=False),
         Binding("shift+tab", "prev_tab", "Prev Tab", priority=True, show=False),
-        Binding("n", "page_next", "Next Page", show=False),
-        Binding("p", "page_prev", "Prev Page", show=False),
-        Binding("s", "switch_view", "Switch View", show=False),
         Binding("ctrl+c", "quit_confirm", "Quit", priority=True),
     ]
 
     _quit_confirm_window_s: float = 1.2
 
-    def __init__(self, dev_mode: bool = False, use_native_terminal: bool | None = None):
+    def __init__(self, use_native_terminal: bool | None = None):
         """Initialize the dashboard.
 
         Args:
-            dev_mode: If True, shows developer tabs (Watcher, Worker).
             use_native_terminal: If True, use native terminal backend (iTerm2/Kitty).
                                  If False, use tmux.
                                  If None (default), auto-detect from ALINE_TERMINAL_MODE env var.
         """
         super().__init__()
-        self.dev_mode = dev_mode
         self.use_native_terminal = use_native_terminal
         self._native_terminal_mode = self._detect_native_mode()
         logger.info(
-            f"AlineDashboard initialized (dev_mode={dev_mode}, "
-            f"native_terminal={self._native_terminal_mode})"
+            f"AlineDashboard initialized (native_terminal={self._native_terminal_mode})"
         )
 
     def _detect_native_mode(self) -> bool:
@@ -103,15 +95,9 @@ class AlineDashboard(App):
         logger.debug("compose() started")
         try:
             yield AlineHeader()
-            tab_ids = self._tab_ids()
-            with TabbedContent(initial=tab_ids[0] if tab_ids else "agents"):
+            with TabbedContent(initial="agents"):
                 with TabPane("Agents", id="agents"):
                     yield AgentsPanel()
-                if self.dev_mode:
-                    with TabPane("Watcher", id="watcher"):
-                        yield WatcherPanel()
-                    with TabPane("Worker", id="worker"):
-                        yield WorkerPanel()
                 with TabPane("Config", id="config"):
                     yield ConfigPanel()
             yield Footer()
@@ -121,8 +107,6 @@ class AlineDashboard(App):
             raise
 
     def _tab_ids(self) -> list[str]:
-        if self.dev_mode:
-            return ["agents", "watcher", "worker", "config"]
         return ["agents", "config"]
 
     def on_mount(self) -> None:
@@ -207,43 +191,9 @@ class AlineDashboard(App):
 
         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()
 
-    def action_page_next(self) -> None:
-        """Go to next page in current panel."""
-        tabbed_content = self.query_one(TabbedContent)
-        active_tab_id = tabbed_content.active
-
-        if active_tab_id == "watcher":
-            self.query_one(WatcherPanel).action_next_page()
-        elif active_tab_id == "worker":
-            self.query_one(WorkerPanel).action_next_page()
-
-    def action_page_prev(self) -> None:
-        """Go to previous page in current panel."""
-        tabbed_content = self.query_one(TabbedContent)
-        active_tab_id = tabbed_content.active
-
-        if active_tab_id == "watcher":
-            self.query_one(WatcherPanel).action_prev_page()
-        elif active_tab_id == "worker":
-            self.query_one(WorkerPanel).action_prev_page()
-
-    def action_switch_view(self) -> None:
-        """Switch view in current panel (if supported)."""
-        tabbed_content = self.query_one(TabbedContent)
-        active_tab_id = tabbed_content.active
-
-        if active_tab_id == "watcher":
-            self.query_one(WatcherPanel).action_switch_view()
-        elif active_tab_id == "worker":
-            self.query_one(WorkerPanel).action_switch_view()
-
     def action_help(self) -> None:
         """Show help information."""
         from .screens import HelpScreen