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

realign/commands/export_shares.py

@@ -15,6 +15,7 @@ import secrets
 import hashlib
 import base64
 import threading
+import shutil
 from urllib.parse import urlparse
 from collections import defaultdict
 from dataclasses import dataclass
@@ -1675,6 +1676,49 @@ def _extend_share_expiry(
     return None
 
 
+def _update_share_content(
+    backend_url: str,
+    share_id: str,
+    token: str,
+    conversation_data: dict,
+    expected_version: int = 0,
+) -> dict:
+    """
+    Push updated content to an existing share via PUT /api/share/{id}.
+
+    Args:
+        backend_url: Backend server URL
+        share_id: Share ID on the server
+        token: Admin or contributor token for auth
+        conversation_data: Full conversation data to replace current content
+        expected_version: Optimistic locking version (409 on mismatch)
+
+    Returns:
+        Response dict with success, version fields
+
+    Raises:
+        RuntimeError on upload failure
+        httpx.HTTPStatusError with 409 status on version conflict
+    """
+    if not HTTPX_AVAILABLE:
+        raise RuntimeError("httpx package not installed. Run: pip install httpx")
+
+    headers = {
+        "X-Token": token,
+        "X-Expected-Version": str(expected_version),
+        "Content-Type": "application/json",
+    }
+
+    response = httpx.put(
+        f"{backend_url}/api/share/{share_id}",
+        headers=headers,
+        json={"conversation_data": conversation_data},
+        timeout=60.0,
+    )
+    response.raise_for_status()
+    return response.json()
+
+
 def _standard_upload(
     encrypted_payload: dict,
     metadata: dict,
@@ -2523,6 +2567,59 @@ def display_share_result(
     console.print(f"[bold]👁️  Max Views:[/bold] {max_views}\n")
 
 
+def _run_clipboard_command(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_to_clipboard(text: str) -> bool:
+    if not text:
+        return False
+
+    if shutil.which("pbcopy"):
+        if _run_clipboard_command(["pbcopy"], text):
+            return True
+
+    if os.name == "nt" and shutil.which("clip"):
+        if _run_clipboard_command(["clip"], text):
+            return True
+
+    if shutil.which("wl-copy"):
+        if _run_clipboard_command(["wl-copy"], text):
+            return True
+
+    if shutil.which("xclip"):
+        if _run_clipboard_command(["xclip", "-selection", "clipboard"], text):
+            return True
+
+    if shutil.which("xsel"):
+        if _run_clipboard_command(["xsel", "--clipboard", "--input"], text):
+            return True
+
+    return False
+
+
+def _copy_share_to_clipboard(share_url: Optional[str], slack_message: Optional[str]) -> bool:
+    if not share_url:
+        return False
+    if slack_message:
+        text_to_copy = f"{slack_message}\n\n{share_url}"
+    else:
+        text_to_copy = share_url
+    return _copy_text_to_clipboard(text_to_copy)
+
+
 def _export_by_events_interactive(
     all_commits: List,
     shadow_git: Path,
@@ -3616,7 +3713,358 @@ def export_shares_interactive_command(
             max_views=max_views,
             admin_token=result.get("admin_token"),
         )
+        copied = _copy_share_to_clipboard(
+            result.get("share_url"),
+            ui_metadata.get("slack_message") if ui_metadata else None,
+        )
+        if copied:
+            print("📋 Copied Slack message and share link to clipboard.")
 
     if not json_output:
         logger.info(f"======== Interactive export completed: {result['share_url']} ========")
     return 0
+
+
+def export_agent_shares_command(
+    agent_id: str,
+    password: Optional[str] = None,
+    expiry_days: int = 7,
+    max_views: int = 100,
+    backend_url: Optional[str] = None,
+    enable_mcp: bool = True,
+    json_output: bool = False,
+    compact: bool = True,
+    max_tool_result_chars: int = 8_000,
+    max_tool_command_chars: int = 2_000,
+    progress_callback: Optional[Callable[[str], None]] = None,
+) -> int:
+    """
+    Export all sessions associated with an agent and generate a share link.
+
+    This function creates a synthetic event structure from agent sessions,
+    generates UI metadata (Slack message), uploads to backend, and returns
+    the share link.
+
+    Args:
+        agent_id: The agent_info ID to export sessions for
+        password: Encryption password (if None, no encryption)
+        expiry_days: Share expiry in days
+        max_views: Maximum number of views
+        backend_url: Backend server URL (uses config default if None)
+        enable_mcp: Whether to include MCP instructions
+        json_output: If True, output JSON format
+        compact: Whether to compact the export data
+        max_tool_result_chars: Max chars for tool results (with compact)
+        max_tool_command_chars: Max chars for tool commands (with compact)
+        progress_callback: Optional callback for progress updates (message: str) -> None
+
+    Returns:
+        0 on success, 1 on error
+    """
+    def _progress(msg: str) -> None:
+        if progress_callback:
+            progress_callback(msg)
+
+    if not json_output:
+        logger.info(f"======== Export agent shares command started for agent {agent_id} ========")
+
+    # Check dependencies
+    if not CRYPTO_AVAILABLE:
+        if not json_output:
+            print("Error: cryptography package not installed", file=sys.stderr)
+        return 1
+
+    if not HTTPX_AVAILABLE:
+        if not json_output:
+            print("Error: httpx package not installed", file=sys.stderr)
+        return 1
+
+    # Check authentication
+    if not is_logged_in():
+        if not json_output:
+            print("Error: Not logged in. Please run 'aline login' first.", file=sys.stderr)
+        return 1
+
+    _progress("Fetching agent info...")
+
+    # Get backend URL
+    if backend_url is None:
+        from ..config import ReAlignConfig
+
+        config = ReAlignConfig.load()
+        backend_url = config.share_backend_url
+
+    # Get database
+    from ..db import get_database
+
+    db = get_database()
+
+    # Get agent info
+    agent_info = db.get_agent_info(agent_id)
+    if not agent_info:
+        if not json_output:
+            print(f"Error: Agent not found: {agent_id}", file=sys.stderr)
+        return 1
+
+    # Check for existing share (re-share → sync instead of new link)
+    if (
+        not password
+        and agent_info.share_url
+        and agent_info.share_id
+        and (agent_info.share_admin_token or agent_info.share_contributor_token)
+    ):
+        _progress("Agent already shared, syncing...")
+        try:
+            from .sync_agent import sync_agent_command
+
+            sync_result = sync_agent_command(
+                agent_id=agent_id,
+                backend_url=backend_url,
+                progress_callback=progress_callback,
+            )
+            if sync_result.get("success"):
+                # Extend expiry if we have admin token
+                if agent_info.share_admin_token:
+                    try:
+                        _extend_share_expiry(
+                            backend_url=backend_url,
+                            share_id=agent_info.share_id,
+                            admin_token=agent_info.share_admin_token,
+                            expiry_days=expiry_days,
+                        )
+                    except Exception as ext_err:
+                        logger.warning(f"Failed to extend share expiry: {ext_err}")
+
+                if json_output:
+                    output_data = {
+                        "agent_id": agent_id,
+                        "agent_name": agent_info.name,
+                        "share_link": agent_info.share_url,
+                        "synced": True,
+                        "sessions_pulled": sync_result.get("sessions_pulled", 0),
+                        "sessions_pushed": sync_result.get("sessions_pushed", 0),
+                    }
+                    print(json.dumps(output_data, ensure_ascii=False, indent=2))
+                else:
+                    pulled = sync_result.get("sessions_pulled", 0)
+                    pushed = sync_result.get("sessions_pushed", 0)
+                    print(f"\n🔄 Synced agent: {agent_info.name}")
+                    print(f"   Pulled {pulled} session(s), pushed {pushed} session(s)")
+                    print(f"🔗 Share link: {agent_info.share_url}")
+                    copied = _copy_share_to_clipboard(agent_info.share_url, None)
+                    if copied:
+                        print("📋 Copied share link to clipboard.")
+                return 0
+            else:
+                err = sync_result.get("error", "Unknown sync error")
+                logger.warning(f"Sync failed, falling through to new share: {err}")
+                if not json_output:
+                    print(f"⚠️  Sync failed ({err}), creating new share link...", file=sys.stderr)
+        except ImportError:
+            logger.warning("sync_agent module not available, creating new share")
+        except Exception as e:
+            logger.warning(f"Sync failed, falling through to new share: {e}")
+            if not json_output:
+                print(f"⚠️  Sync failed ({e}), creating new share link...", file=sys.stderr)
+
+    # Get sessions for this agent
+    session_records = db.get_sessions_by_agent_id(agent_id)
+    if not session_records:
+        if not json_output:
+            print(f"Error: Agent has no sessions to share", file=sys.stderr)
+        return 1
+
+    _progress(f"Found {len(session_records)} session(s)")
+
+    # Build exportable sessions
+    selected_sessions = build_exportable_sessions_from_records(session_records)
+    if not selected_sessions:
+        if not json_output:
+            print("Error: No sessions found for agent", file=sys.stderr)
+        return 1
+
+    # Create a synthetic event structure for the agent
+    # We use the agent name/description as event title/description
+    event_title = agent_info.name or "Agent Sessions"
+    event_description = agent_info.description or f"Sessions from agent: {agent_info.name}"
+
+    # Create a synthetic ExportableEvent
+    synthetic_event = ExportableEvent(
+        index=1,
+        event_id=f"agent-{agent_id}",
+        title=event_title,
+        description=event_description,
+        event_type="agent",
+        status="active",
+        updated_at=datetime.now(timezone.utc),
+        sessions=session_records,
+    )
+
+    # Build conversation data
+    _progress("Building conversation data...")
+
+    username = os.environ.get("USER") or os.environ.get("USERNAME") or "anonymous"
+
+    compaction = None
+    if compact:
+        compaction = ExportCompactionConfig(
+            enabled=True,
+            max_tool_result_chars=max_tool_result_chars,
+            max_tool_command_chars=max_tool_command_chars,
+        )
+
+    try:
+        conversation_data = build_enhanced_conversation_data(
+            selected_event=synthetic_event,
+            selected_sessions=selected_sessions,
+            username=username,
+            db=db,
+            compaction=compaction,
+        )
+    except Exception as e:
+        if not json_output:
+            print(f"Error: Failed to build conversation data: {e}", file=sys.stderr)
+        logger.error(f"Failed to build conversation data: {e}", exc_info=True)
+        return 1
+
+    if not conversation_data.get("sessions"):
+        if not json_output:
+            print("Error: No sessions found in conversation data", file=sys.stderr)
+        return 1
+
+    # Generate UI metadata with LLM
+    _progress("Generating share message...")
+
+    from ..config import ReAlignConfig
+
+    config = ReAlignConfig.load()
+    ui_metadata, _ = generate_ui_metadata_with_llm(
+        conversation_data,
+        [],  # No commits
+        event_title=event_title,
+        event_description=event_description,
+        provider=config.llm_provider,
+        preset_id="default",
+        silent=json_output,
+    )
+
+    if ui_metadata:
+        conversation_data["ui_metadata"] = ui_metadata
+    else:
+        conversation_data["ui_metadata"] = {
+            "title": event_title,
+            "description": event_description,
+        }
+
+    # Add MCP instructions if enabled
+    if enable_mcp:
+        conversation_data["ui_metadata"]["mcp_instructions"] = {
+            "tool_name": "ask_shared_conversation",
+            "usage": "Local AI agents can install the aline MCP server and use the 'ask_shared_conversation' tool to query this conversation programmatically.",
+        }
+
+    # Include sync_metadata placeholder (contributor_token will be added after upload for unencrypted shares)
+    if not password:
+        conversation_data["sync_metadata"] = {
+            "contributor_token": None,  # Will be populated after upload
+            "sync_version": 0,
+        }
+
+    # Upload to backend (no encryption for agent shares by default)
+    _progress("Uploading to cloud...")
+
+    metadata = {
+        "username": username,
+        "expiry_days": expiry_days,
+        "max_views": max_views,
+    }
+
+    try:
+        if password:
+            encrypted_payload = encrypt_conversation_data(conversation_data, password)
+            result = upload_to_backend(
+                encrypted_payload=encrypted_payload,
+                metadata=metadata,
+                backend_url=backend_url,
+                ui_metadata=conversation_data.get("ui_metadata"),
+                background=True,
+            )
+        else:
+            result = upload_to_backend_unencrypted(
+                conversation_data=conversation_data,
+                metadata=metadata,
+                backend_url=backend_url,
+                background=True,
+            )
+    except Exception as e:
+        if not json_output:
+            print(f"Error: Upload failed: {e}", file=sys.stderr)
+        logger.error(f"Upload failed: {e}", exc_info=True)
+        return 1
+
+    share_url = result.get("share_url")
+    slack_message = ui_metadata.get("slack_message") if ui_metadata else None
+
+    # Store sync metadata for unencrypted shares
+    if not password and share_url:
+        share_id_result = result.get("share_id") or _extract_share_id_from_url(share_url)
+        admin_token = result.get("admin_token")
+        contributor_token = result.get("contributor_token")
+        expiry_at = result.get("expiry_at")
+
+        if share_id_result:
+            try:
+                db.update_agent_sync_metadata(
+                    agent_id,
+                    share_id=share_id_result,
+                    share_url=share_url,
+                    share_admin_token=admin_token,
+                    share_contributor_token=contributor_token,
+                    share_expiry_at=expiry_at,
+                    last_synced_at=datetime.now(timezone.utc).isoformat(),
+                    sync_version=0,
+                )
+            except Exception as e:
+                logger.warning(f"Failed to store sync metadata: {e}")
+
+            # Re-upload with contributor_token embedded in sync_metadata
+            # so importers can get it
+            if contributor_token:
+                try:
+                    conversation_data["sync_metadata"] = {
+                        "contributor_token": contributor_token,
+                        "sync_version": 0,
+                    }
+                    _update_share_content(
+                        backend_url=backend_url,
+                        share_id=share_id_result,
+                        token=admin_token or contributor_token,
+                        conversation_data=conversation_data,
+                        expected_version=0,
+                    )
+                except Exception as e:
+                    logger.warning(f"Failed to re-upload with sync metadata: {e}")
+
+    # Output results
+    if json_output:
+        output_data = {
+            "agent_id": agent_id,
+            "agent_name": agent_info.name,
+            "share_link": share_url,
+            "slack_message": slack_message,
+            "session_count": len(selected_sessions),
+            "password": password,
+        }
+        print(json.dumps(output_data, ensure_ascii=False, indent=2))
+    else:
+        print(f"\n✅ Shared {len(selected_sessions)} session(s) from agent: {agent_info.name}")
+        print(f"🔗 Share link: {share_url}")
+        if slack_message:
+            print(f"\n📝 Slack message:\n{slack_message}")
+        copied = _copy_share_to_clipboard(share_url, slack_message)
+        if copied:
+            print("📋 Copied Slack message and share link to clipboard.")
+
+    if not json_output:
+        logger.info(f"======== Agent export completed: {share_url} ========")
+    return 0

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]")