aline-ai 0.7.3__py3-none-any.whl → 0.7.5__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 = {}
@@ -253,16 +301,11 @@ def sync_agent_command(
         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 = None
-            if isinstance(remote_updated_at, str) and remote_updated_at:
-                try:
-                    remote_dt = datetime.fromisoformat(remote_updated_at.replace("Z", "+00:00"))
-                except Exception:
-                    remote_dt = None
+            remote_dt = _parse_iso_datetime_to_utc(remote_updated_at)
 
             local_dt = getattr(agent_info, "updated_at", None)
-            if hasattr(local_dt, "tzinfo") and local_dt and local_dt.tzinfo is None:
-                local_dt = local_dt.replace(tzinfo=timezone.utc)
+            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):
@@ -317,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}")
@@ -355,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)}
 
@@ -381,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 = []
@@ -400,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"
 

realign/commands/upgrade.py

@@ -1,6 +1,7 @@
 """ReAlign upgrade command - Upgrade database schema to latest version."""
 
 from pathlib import Path
+import os
 import subprocess
 import typer
 from rich.console import Console
@@ -13,6 +14,97 @@ from ..db.schema import SCHEMA_VERSION, get_migration_scripts
 console = Console()
 
 
+def _env_truthy(name: str) -> bool:
+    value = os.environ.get(name, "").strip().lower()
+    return value in {"1", "true", "yes", "y", "on"}
+
+
+def _stop_daemons_best_effort_for_package_upgrade() -> None:
+    """Stop watcher/worker daemons (best-effort) before upgrading the package.
+
+    Upgrading the installed package while old daemons are running can leave the system
+    in a mixed-version state (old processes continue running old code).
+    """
+    try:
+        from . import watcher as watcher_cmd
+
+        try:
+            watcher_running = bool(watcher_cmd._is_watcher_running())
+        except Exception:
+            watcher_running = False
+        if watcher_running:
+            console.print("[dim]Stopping watcher for upgrade...[/dim]")
+            try:
+                watcher_cmd.watcher_stop_command()
+            except Exception:
+                pass
+    except Exception:
+        pass
+
+    try:
+        from . import worker as worker_cmd
+
+        try:
+            worker_running, _pid, _mode = worker_cmd.detect_worker_process()
+        except Exception:
+            worker_running = False
+        if worker_running:
+            console.print("[dim]Stopping worker for upgrade...[/dim]")
+            try:
+                worker_cmd.worker_stop_command()
+            except Exception:
+                pass
+    except Exception:
+        pass
+
+
+def _detect_running_tmux_dashboard() -> tuple[bool, str, str]:
+    """Detect an Aline-managed tmux dashboard session (best-effort)."""
+    try:
+        from ..dashboard.tmux_manager import OUTER_SESSION, OUTER_SOCKET  # type: ignore
+
+        outer_session = str(OUTER_SESSION)
+        outer_socket = str(OUTER_SOCKET)
+    except Exception:
+        # Keep defaults stable for older versions / import failures.
+        outer_session = "aline"
+        outer_socket = "aline_dash"
+
+    try:
+        proc = subprocess.run(
+            ["tmux", "-L", outer_socket, "has-session", "-t", outer_session],
+            capture_output=True,
+            text=True,
+            timeout=1.5,
+            check=False,
+        )
+        return proc.returncode == 0, outer_socket, outer_session
+    except Exception:
+        return False, outer_socket, outer_session
+
+
+def _run_doctor_after_upgrade() -> None:
+    if _env_truthy("ALINE_SKIP_DOCTOR_AFTER_UPGRADE"):
+        console.print("[dim]Skipping 'aline doctor' (ALINE_SKIP_DOCTOR_AFTER_UPGRADE=1).[/dim]\n")
+        return
+
+    console.print("\n[dim]Running 'aline doctor' to finalize the update...[/dim]\n")
+    try:
+        result = subprocess.run(["aline", "doctor"], capture_output=False)
+        if result.returncode == 0:
+            console.print("\n[green]✓ 'aline doctor' completed.[/green]\n")
+        else:
+            console.print(
+                f"\n[yellow]⚠ 'aline doctor' exited with code {result.returncode}.[/yellow]\n"
+            )
+    except FileNotFoundError:
+        console.print(
+            "\n[yellow]⚠ Could not find 'aline' on PATH to run doctor. Please run: aline doctor[/yellow]\n"
+        )
+    except Exception as e:
+        console.print(f"\n[yellow]⚠ Failed to run 'aline doctor': {e}[/yellow]\n")
+
+
 def get_latest_pypi_version() -> Optional[str]:
     """Fetch the latest version of aline-ai from PyPI.
 
@@ -110,6 +202,30 @@ def check_and_prompt_update() -> bool:
         console.print("[dim]Update skipped.[/dim]\n")
         return False
 
+    # Best practice: stop daemons and close dashboards before upgrading.
+    # Otherwise users can end up with old processes still running old code.
+    dash_running, dash_socket, dash_session = _detect_running_tmux_dashboard()
+    if dash_running:
+        console.print(
+            "\n[bold yellow]⚠ Detected a running Aline dashboard tmux session.[/bold yellow]"
+        )
+        console.print(
+            f"[dim]Close it before upgrading to avoid mixed versions. "
+            f"(Command: tmux -L {dash_socket} kill-session -t {dash_session})[/dim]\n"
+        )
+        try:
+            proceed = console.input(
+                "[dim]Continue upgrade anyway? ([/dim][green]y[/green][dim]/[/dim][yellow]n[/yellow][dim]):[/dim] "
+            ).strip().lower()
+        except (EOFError, KeyboardInterrupt):
+            console.print("\n[dim]Update skipped.[/dim]\n")
+            return False
+        if proceed not in ("y", "yes"):
+            console.print("[dim]Update skipped.[/dim]\n")
+            return False
+
+    _stop_daemons_best_effort_for_package_upgrade()
+
     # Perform update using pipx
     console.print("\n[bold]Updating aline-ai via pipx...[/bold]\n")
 
@@ -123,6 +239,7 @@ def check_and_prompt_update() -> bool:
             console.print(
                 f"\n[bold green]✓ Successfully updated to {latest_version}![/bold green]"
             )
+            _run_doctor_after_upgrade()
             console.print("[dim]Please restart 'aline' to use the new version.[/dim]\n")
             return True
         else: