aline-ai 0.7.2__py3-none-any.whl → 0.7.4__py3-none-any.whl

realign/commands/sync_agent.py

@@ -11,6 +11,7 @@ Sync works with unencrypted shares only.
 import json
 import os
 import logging
+import time
 from datetime import datetime, timezone
 from typing import Optional, Dict, Any, Callable
 
@@ -28,6 +29,40 @@ logger = setup_logger("realign.commands.sync_agent", "sync_agent.log")
 MAX_SYNC_RETRIES = 3
 
 
+def _ensure_aware_utc(dt: datetime) -> datetime:
+    if dt.tzinfo is None:
+        return dt.replace(tzinfo=timezone.utc)
+    return dt
+
+
+def _parse_iso_datetime_to_utc(value: Any) -> Optional[datetime]:
+    if not isinstance(value, str) or not value:
+        return None
+    try:
+        dt = datetime.fromisoformat(value.replace("Z", "+00:00"))
+        return _ensure_aware_utc(dt)
+    except Exception:
+        return None
+
+
+def _extract_httpx_conflict_current_version(err: Exception) -> Optional[int]:
+    if not HTTPX_AVAILABLE:
+        return None
+    if not isinstance(err, httpx.HTTPStatusError):
+        return None
+    if err.response is None or err.response.status_code != 409:
+        return None
+    try:
+        payload = err.response.json()
+    except Exception:
+        return None
+    current = payload.get("current_version")
+    try:
+        return int(current)
+    except Exception:
+        return None
+
+
 def sync_agent_command(
     agent_id: str,
     backend_url: Optional[str] = None,
@@ -52,6 +87,7 @@ def sync_agent_command(
         {"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)
@@ -84,7 +120,10 @@ def sync_agent_command(
             agent_info = matches[0]
             agent_id = agent_info.id
         elif len(matches) > 1:
-            return {"success": False, "error": f"Ambiguous agent_id prefix '{agent_id}' matches {len(matches)} agents"}
+            return {
+                "success": False,
+                "error": f"Ambiguous agent_id prefix '{agent_id}' matches {len(matches)} agents",
+            }
         else:
             return {"success": False, "error": f"Agent not found: {agent_id}"}
 
@@ -93,7 +132,10 @@ def sync_agent_command(
 
     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)"}
+        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
@@ -164,7 +206,8 @@ def sync_agent_command(
 
         # Check if any turns in this session are new to THIS AGENT (not globally)
         new_turns = [
-            t for t in session_turns
+            t
+            for t in session_turns
             if t.get("content_hash") and t["content_hash"] not in local_content_hashes
         ]
 
@@ -186,8 +229,11 @@ def sync_agent_command(
                 session_data, f"agent-{agent_id}", agent_info.share_url, db, force=False
             )
             # Count as pulled if: created new session/turns, or session was new/needed linking
-            if (import_result.get("sessions", 0) > 0 or import_result.get("turns", 0) > 0
-                    or should_count):
+            if (
+                import_result.get("sessions", 0) > 0
+                or import_result.get("turns", 0) > 0
+                or should_count
+            ):
                 sessions_pulled += 1
         except Exception as e:
             logger.error(f"Failed to import remote session {session_id}: {e}")
@@ -206,11 +252,13 @@ def sync_agent_command(
     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_dt = _parse_iso_datetime_to_utc(remote_updated_at)
+            local_dt = (
+                _ensure_aware_utc(agent_info.updated_at)
+                if isinstance(agent_info.updated_at, datetime)
+                else None
+            )
+            if remote_dt and local_dt and remote_dt > local_dt:
                 remote_name = remote_event.get("title")
                 remote_desc = remote_event.get("description")
                 updates = {}
@@ -240,6 +288,53 @@ def sync_agent_command(
         if new_local_turns:
             sessions_pushed += 1
 
+    # Skip push if there's nothing new to send.
+    # This avoids re-uploading large, unchanged payloads (which can hit serverless limits and show up as 403/413).
+    needs_push_metadata = False
+    try:
+        remote_title = remote_event.get("title")
+        remote_desc = remote_event.get("description")
+
+        local_title = agent_info.name
+        local_desc = agent_info.description
+
+        has_metadata_diff = (remote_title != local_title) or (remote_desc != local_desc)
+        if has_metadata_diff and not description_updated:
+            remote_updated_at = remote_event.get("updated_at")
+            remote_dt = _parse_iso_datetime_to_utc(remote_updated_at)
+
+            local_dt = getattr(agent_info, "updated_at", None)
+            if isinstance(local_dt, datetime):
+                local_dt = _ensure_aware_utc(local_dt)
+
+            # If remote has no timestamp, assume local should win. Otherwise, push only if local is newer.
+            if remote_dt is None or (local_dt and remote_dt and local_dt > remote_dt):
+                needs_push_metadata = True
+    except Exception as e:
+        logger.warning(f"Failed to compute metadata push necessity (non-fatal): {e}")
+
+    if sessions_pushed == 0 and not needs_push_metadata:
+        now_iso = datetime.now(timezone.utc).isoformat()
+        try:
+            db.update_agent_sync_metadata(
+                agent_id,
+                last_synced_at=now_iso,
+                sync_version=remote_sync_version,
+            )
+        except Exception as e:
+            logger.warning(f"Failed to update local sync metadata after no-op sync: {e}")
+
+        _progress("No changes to push.")
+        _progress("Sync complete!")
+
+        return {
+            "success": True,
+            "sessions_pulled": sessions_pulled,
+            "sessions_pushed": 0,
+            "description_updated": description_updated,
+            "new_sync_version": remote_sync_version,
+        }
+
     # Build full conversation data for push
     merged_conversation = _build_merged_conversation_data(
         agent_info=agent_info,
@@ -265,14 +360,138 @@ def sync_agent_command(
             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
+            conflict_current_version = _extract_httpx_conflict_current_version(e)
+            is_conflict = (
+                HTTPX_AVAILABLE
+                and isinstance(e, httpx.HTTPStatusError)
+                and e.response is not None
+                and e.response.status_code == 409
+            )
+            if is_conflict and attempt < MAX_SYNC_RETRIES - 1:
+                if conflict_current_version is not None:
+                    _progress(
+                        "Version conflict "
+                        f"(remote={conflict_current_version}, local_expected={new_version}), "
+                        f"retrying ({attempt + 2}/{MAX_SYNC_RETRIES})..."
+                    )
+                else:
+                    _progress(f"Version conflict, retrying ({attempt + 2}/{MAX_SYNC_RETRIES})...")
+
+                # Re-pull to re-merge any remote changes; also bypass potential CDN caching.
                 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)
+                    remote_version = conv.get("sync_metadata", {}).get("sync_version", 0)
+                    try:
+                        remote_version_int = int(remote_version)
+                    except Exception:
+                        remote_version_int = 0
+
+                    if conflict_current_version is not None:
+                        remote_version_int = max(remote_version_int, conflict_current_version)
+
+                    new_version = remote_version_int
+
+                    # Rebuild merge inputs from refreshed remote snapshot.
+                    remote_sessions_data = conv.get("sessions", [])
+                    remote_event = conv.get("event", {})
+
+                    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)
+
+                    # Re-import remote sessions (idempotent via content_hash dedup) and re-merge metadata.
+                    try:
+                        from .import_shares import import_session_with_turns
+
+                        local_content_hashes = db.get_agent_content_hashes(agent_id)
+                        for session_data in remote_sessions_data:
+                            session_id = session_data.get("session_id", "")
+                            session_turns = session_data.get("turns", [])
+
+                            new_turns = [
+                                t
+                                for t in session_turns
+                                if t.get("content_hash")
+                                and t["content_hash"] not in local_content_hashes
+                            ]
+
+                            existing_session = db.get_session_by_id(session_id)
+                            session_is_new = existing_session is None
+                            session_needs_linking = (
+                                existing_session and existing_session.agent_id != agent_id
+                            )
+
+                            if not new_turns and not session_is_new and not session_needs_linking:
+                                continue
+
+                            should_count = session_is_new or session_needs_linking
+                            try:
+                                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
+                                    or should_count
+                                ):
+                                    sessions_pulled += 1
+                            except Exception as ie:
+                                logger.error(f"Failed to import remote session {session_id}: {ie}")
+                                if should_count:
+                                    sessions_pulled += 1
+
+                            try:
+                                db.update_session_agent_id(session_id, agent_id)
+                            except Exception as le:
+                                logger.error(f"Failed to link session {session_id} to agent: {le}")
+
+                        # Re-merge name/description: last-write-wins by updated_at.
+                        refreshed_remote_updated_at = remote_event.get("updated_at")
+                        remote_dt = _parse_iso_datetime_to_utc(refreshed_remote_updated_at)
+                        local_dt = (
+                            _ensure_aware_utc(agent_info.updated_at)
+                            if isinstance(agent_info.updated_at, datetime)
+                            else None
+                        )
+                        if remote_dt and local_dt and 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 merge_e:
+                        logger.warning(
+                            f"Failed to refresh merge after conflict (non-fatal): {merge_e}"
+                        )
+
+                    # Rebuild payload from refreshed local state before retrying.
+                    local_sessions = db.get_sessions_by_agent_id(agent_id)
+                    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,
+                    )
+
+                elif conflict_current_version is not None:
+                    # If pull fails, fall back to server-provided current_version.
+                    new_version = max(new_version, conflict_current_version)
                 continue
             else:
                 logger.error(f"Push failed after {attempt + 1} attempts: {e}")
@@ -303,7 +522,8 @@ def _pull_remote(backend_url: str, share_id: str) -> dict:
         from .import_shares import download_share_data
 
         share_url = f"{backend_url}/share/{share_id}"
-        return download_share_data(share_url, password=None)
+        cache_buster = str(int(time.time() * 1000))
+        return download_share_data(share_url, password=None, cache_buster=cache_buster)
     except Exception as e:
         return {"success": False, "error": str(e)}
 
@@ -329,8 +549,12 @@ def _build_merged_conversation_data(
         "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,
+        "created_at": (
+            _ensure_aware_utc(agent_info.created_at).isoformat() if agent_info.created_at else None
+        ),
+        "updated_at": (
+            _ensure_aware_utc(agent_info.updated_at).isoformat() if agent_info.updated_at else None
+        ),
     }
 
     sessions_data = []
@@ -348,32 +572,38 @@ def _build_merged_conversation_data(
                         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,
-        })
+            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"