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

realign/commands/export_shares.py

@@ -1703,6 +1703,21 @@ def _update_share_content(
     if not HTTPX_AVAILABLE:
         raise RuntimeError("httpx package not installed. Run: pip install httpx")
 
+    # Large payloads can exceed serverless request limits; fall back to chunked update.
+    update_payload = {"conversation_data": conversation_data}
+    payload_size = len(json.dumps(update_payload).encode("utf-8"))
+    if payload_size > CHUNKED_UPLOAD_THRESHOLD:
+        logger.info(
+            f"Update payload size ({payload_size / 1024 / 1024:.2f}MB) exceeds threshold, using chunked update"
+        )
+        return _chunked_update_share_content(
+            backend_url=backend_url,
+            share_id=share_id,
+            token=token,
+            conversation_data=conversation_data,
+            expected_version=expected_version,
+        )
+
     headers = {
         "X-Token": token,
         "X-Expected-Version": str(expected_version),
@@ -1712,7 +1727,7 @@ def _update_share_content(
     response = httpx.put(
         f"{backend_url}/api/share/{share_id}",
         headers=headers,
-        json={"conversation_data": conversation_data},
+        json=update_payload,
         timeout=60.0,
     )
     response.raise_for_status()
@@ -1752,64 +1767,148 @@ def _upload_chunks_and_complete(
     upload_id: str,
     backend_url: str,
     progress_callback: Optional[Callable] = None,
-    auth_headers: Optional[Dict[str, str]] = None,
-) -> None:
+    headers_provider: Optional[Callable[[], Dict[str, str]]] = None,
+) -> Optional[dict]:
     """
     Helper function to upload chunks and complete the upload.
     Can be run in background thread.
     """
+    import time
+
     total_chunks = len(chunks)
-    headers = auth_headers or {}
+
+    def _headers() -> Dict[str, str]:
+        try:
+            return dict(headers_provider()) if headers_provider else {}
+        except Exception:
+            return {}
+
+    def _post_with_retries(url: str, payload: dict, timeout: float) -> Optional[dict]:
+        max_attempts = 3
+        for attempt in range(max_attempts):
+            try:
+                response = httpx.post(url, json=payload, headers=_headers(), timeout=timeout)
+                response.raise_for_status()
+                return response.json()
+            except httpx.HTTPStatusError as e:
+                status = getattr(e.response, "status_code", None)
+                retriable = status in (401, 403, 409, 429, 500, 502, 503, 504)
+                if retriable and attempt < max_attempts - 1:
+                    time.sleep(0.5 * (2**attempt))
+                    continue
+                logger.error(f"POST failed: {e}")
+                return None
+            except httpx.HTTPError as e:
+                if attempt < max_attempts - 1:
+                    time.sleep(0.5 * (2**attempt))
+                    continue
+                logger.error(f"POST failed: {e}")
+                return None
 
     # Upload each chunk
     for i, chunk in enumerate(chunks):
         if progress_callback:
             progress_callback(i + 1, total_chunks + 2, f"Uploading chunk {i + 1}/{total_chunks}...")
 
-        try:
-            chunk_payload = {
-                "upload_id": upload_id,
-                "chunk_index": i,
-                "data": chunk,
-            }
+        chunk_payload = {
+            "upload_id": upload_id,
+            "chunk_index": i,
+            "data": chunk,
+        }
 
-            response = httpx.post(
-                f"{backend_url}/api/share/chunk/upload",
-                json=chunk_payload,
-                headers=headers,
-                timeout=60.0,  # Longer timeout for chunk uploads
-            )
-            response.raise_for_status()
-            result = response.json()
-            logger.debug(
-                f"Chunk {i + 1}/{total_chunks} uploaded, received: {result.get('received_chunks')}"
-            )
+        result = _post_with_retries(
+            f"{backend_url}/api/share/chunk/upload",
+            chunk_payload,
+            timeout=60.0,  # Longer timeout for chunk uploads
+        )
+        if not result:
+            logger.error(f"Failed to upload chunk {i}")
+            return None
 
-        except httpx.HTTPError as e:
-            logger.error(f"Failed to upload chunk {i}: {e}")
-            # In background mode, we just log the error
-            return
+        logger.debug(
+            f"Chunk {i + 1}/{total_chunks} uploaded, received: {result.get('received_chunks')}"
+        )
 
     # Complete upload
     if progress_callback:
         progress_callback(total_chunks + 1, total_chunks + 2, "Finalizing upload...")
 
-    try:
-        response = httpx.post(
-            f"{backend_url}/api/share/chunk/complete",
-            json={"upload_id": upload_id},
-            headers=headers,
-            timeout=60.0,
-        )
-        response.raise_for_status()
-        result = response.json()
-        logger.info(f"Chunked upload completed: {result.get('share_url')}")
+    result = _post_with_retries(
+        f"{backend_url}/api/share/chunk/complete",
+        {"upload_id": upload_id},
+        timeout=60.0,
+    )
+    if not result:
+        logger.error("Failed to complete chunked upload")
+        return None
 
-        if progress_callback:
-            progress_callback(total_chunks + 2, total_chunks + 2, "Upload complete!")
+    logger.info(f"Chunked upload completed: {result.get('share_url')}")
 
-    except httpx.HTTPError as e:
-        logger.error(f"Failed to complete chunked upload: {e}")
+    if progress_callback:
+        progress_callback(total_chunks + 2, total_chunks + 2, "Upload complete!")
+
+    return result
+
+
+def _chunked_update_share_content(
+    backend_url: str,
+    share_id: str,
+    token: str,
+    conversation_data: dict,
+    expected_version: int,
+) -> dict:
+    data_str = json.dumps(conversation_data)
+    data_bytes = data_str.encode("utf-8")
+    total_size = len(data_bytes)
+
+    chunks: List[str] = []
+    for i in range(0, total_size, CHUNK_SIZE):
+        chunk_data = data_bytes[i : i + CHUNK_SIZE]
+        chunks.append(base64.b64encode(chunk_data).decode("ascii"))
+
+    total_chunks = len(chunks)
+    logger.info(f"Splitting update into {total_chunks} chunks")
+
+    init_payload = {
+        "total_chunks": total_chunks,
+        "total_size": total_size,
+        "metadata": {},
+        "encrypted_info": None,
+        "ui_metadata": conversation_data.get("ui_metadata"),
+        "share_id": share_id,
+        "operation": "update",
+    }
+
+    def headers_provider() -> Dict[str, str]:
+        # Keep bearer auth when available; required for create, optional for update.
+        headers = get_auth_headers()
+        headers["X-Token"] = token
+        headers["X-Expected-Version"] = str(expected_version)
+        return headers
+
+    init_headers = headers_provider()
+    init_headers["Content-Type"] = "application/json"
+
+    response = httpx.post(
+        f"{backend_url}/api/share/chunk/init",
+        json=init_payload,
+        headers=init_headers,
+        timeout=30.0,
+    )
+    response.raise_for_status()
+    init_result = response.json()
+    upload_id = init_result["upload_id"]
+
+    result = _upload_chunks_and_complete(
+        chunks,
+        upload_id,
+        backend_url,
+        progress_callback=None,
+        headers_provider=headers_provider,
+    )
+    if not result:
+        raise RuntimeError("Failed to complete chunked update")
+    return result
 
 
 def _chunked_upload(
@@ -1857,8 +1956,11 @@ def _chunked_upload(
     if progress_callback:
         progress_callback(0, total_chunks + 2, "Initializing chunked upload...")
 
-    # Get auth headers for Bearer token authentication
-    auth_headers = get_auth_headers()
+    def headers_provider() -> Dict[str, str]:
+        # Refresh token if needed between chunks.
+        headers = get_auth_headers()
+        headers["Content-Type"] = "application/json"
+        return headers
 
     # Step 1: Initialize upload session (now returns share_url immediately)
     try:
@@ -1877,7 +1979,7 @@ def _chunked_upload(
         response = httpx.post(
             f"{backend_url}/api/share/chunk/init",
             json=init_payload,
-            headers=auth_headers,
+            headers=headers_provider(),
             timeout=30.0,
         )
         response.raise_for_status()
@@ -1902,7 +2004,7 @@ def _chunked_upload(
         # but user already has the share URL displayed
         thread = threading.Thread(
             target=_upload_chunks_and_complete,
-            args=(chunks, upload_id, backend_url, None, auth_headers),  # No callback in background
+            args=(chunks, upload_id, backend_url, None, headers_provider),  # No callback in background
             daemon=False,  # Important: let thread complete before process exits
         )
         thread.start()
@@ -1917,14 +2019,17 @@ def _chunked_upload(
         }
 
     # Foreground mode: upload chunks synchronously
-    _upload_chunks_and_complete(chunks, upload_id, backend_url, progress_callback, auth_headers)
-
-    return {
-        "share_id": share_id,
-        "share_url": share_url,
-        "admin_token": admin_token,
-        "expiry_at": expiry_at,
-    }
+    result = _upload_chunks_and_complete(
+        chunks, upload_id, backend_url, progress_callback, headers_provider
+    )
+    if not result:
+        raise RuntimeError("Failed to complete chunked upload")
+    # Preserve init fields if server didn't echo them
+    result.setdefault("share_id", share_id)
+    result.setdefault("share_url", share_url)
+    result.setdefault("admin_token", admin_token)
+    result.setdefault("expiry_at", expiry_at)
+    return result
 
 
 def upload_to_backend_unencrypted(
@@ -2032,8 +2137,10 @@ def _chunked_upload_unencrypted(
     if progress_callback:
         progress_callback(0, total_chunks + 2, "Initializing chunked upload...")
 
-    # Get auth headers for Bearer token authentication
-    auth_headers = get_auth_headers()
+    def headers_provider() -> Dict[str, str]:
+        headers = get_auth_headers()
+        headers["Content-Type"] = "application/json"
+        return headers
 
     # Step 1: Initialize upload session (now returns share_url immediately)
     try:
@@ -2048,7 +2155,7 @@ def _chunked_upload_unencrypted(
         response = httpx.post(
             f"{backend_url}/api/share/chunk/init",
             json=init_payload,
-            headers=auth_headers,
+            headers=headers_provider(),
             timeout=30.0,
         )
         response.raise_for_status()
@@ -2073,7 +2180,7 @@ def _chunked_upload_unencrypted(
         # but user already has the share URL displayed
         thread = threading.Thread(
             target=_upload_chunks_and_complete,
-            args=(chunks, upload_id, backend_url, None, auth_headers),  # No callback in background
+            args=(chunks, upload_id, backend_url, None, headers_provider),  # No callback in background
             daemon=False,  # Important: let thread complete before process exits
         )
         thread.start()
@@ -2088,14 +2195,16 @@ def _chunked_upload_unencrypted(
         }
 
     # Foreground mode: upload chunks synchronously
-    _upload_chunks_and_complete(chunks, upload_id, backend_url, progress_callback, auth_headers)
-
-    return {
-        "share_id": share_id,
-        "share_url": share_url,
-        "admin_token": admin_token,
-        "expiry_at": expiry_at,
-    }
+    result = _upload_chunks_and_complete(
+        chunks, upload_id, backend_url, progress_callback, headers_provider
+    )
+    if not result:
+        raise RuntimeError("Failed to complete chunked upload")
+    result.setdefault("share_id", share_id)
+    result.setdefault("share_url", share_url)
+    result.setdefault("admin_token", admin_token)
+    result.setdefault("expiry_at", expiry_at)
+    return result
 
 
 def clean_text_for_prompt(text: str) -> str:
@@ -3093,6 +3202,10 @@ def export_shares_interactive_command(
         if not json_output:
             print("Error: Not logged in. Please run 'aline login' first.", file=sys.stderr)
         return 1
+    if not get_auth_headers():
+        if not json_output:
+            print("Error: Login expired. Please run 'aline login' again.", file=sys.stderr)
+        return 1
 
     # Get backend URL
     if backend_url is None:
@@ -3784,6 +3897,12 @@ def export_agent_shares_command(
         if not json_output:
             print("Error: Not logged in. Please run 'aline login' first.", file=sys.stderr)
         return 1
+    # is_logged_in() can be true with an expired token + refresh_token; ensure we actually have an access token
+    # before attempting uploads (otherwise the server returns 401/403 and the UX is confusing).
+    if not get_auth_headers():
+        if not json_output:
+            print("Error: Login expired. Please run 'aline login' again.", file=sys.stderr)
+        return 1
 
     _progress("Fetching agent info...")
 
@@ -3990,14 +4109,18 @@ def export_agent_shares_command(
                 metadata=metadata,
                 backend_url=backend_url,
                 ui_metadata=conversation_data.get("ui_metadata"),
-                background=True,
+                background=False,
             )
         else:
+            def upload_progress(current: int, total: int, message: str) -> None:
+                _progress(f"{message} ({current}/{total})")
+
             result = upload_to_backend_unencrypted(
                 conversation_data=conversation_data,
                 metadata=metadata,
                 backend_url=backend_url,
-                background=True,
+                progress_callback=upload_progress,
+                background=False,
             )
     except Exception as e:
         if not json_output:

realign/commands/import_shares.py

@@ -47,6 +47,7 @@ else:
 def download_share_data(
     share_url: str,
     password: Optional[str] = None,
+    cache_buster: Optional[str] = None,
 ) -> Dict[str, Any]:
     """
     Download share data from a share URL.
@@ -62,7 +63,10 @@ def download_share_data(
         {"success": False, "error": str} on failure
     """
     if not HTTPX_AVAILABLE:
-        return {"success": False, "error": "httpx package not installed. Install with: pip install httpx"}
+        return {
+            "success": False,
+            "error": "httpx package not installed. Install with: pip install httpx",
+        }
 
     share_id = extract_share_id(share_url)
     if not share_id:
@@ -101,14 +105,16 @@ def download_share_data(
 
     # Download export data
     try:
-        export_response = httpx.get(
-            f"{backend_url}/api/share/{share_id}/export", headers=headers, timeout=30.0
-        )
+        export_url = f"{backend_url}/api/share/{share_id}/export"
+        if cache_buster:
+            export_url = f"{export_url}?cache_bust={cache_buster}"
+
+        export_response = httpx.get(export_url, 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)
+            raw_data = _download_chunks(backend_url, share_id, headers, total_chunks, cache_buster)
             conversation_data = json.loads(raw_data)
             export_data = {
                 "success": True,
@@ -494,7 +500,9 @@ def import_v2_data(
             share_url=share_url,
             commit_hashes=[],
             # V18: user identity (with backward compatibility for old format)
-            created_by=event_data.get("created_by") or event_data.get("uid") or event_data.get("creator_id"),
+            created_by=event_data.get("created_by")
+            or event_data.get("uid")
+            or event_data.get("creator_id"),
             shared_by=config.uid,  # Current user is the importer
         )
 
@@ -603,7 +611,9 @@ def import_session_with_turns(
             summary_locked_until=None,
             summary_error=None,
             # V18: user identity (with backward compatibility for old format)
-            created_by=session_data.get("created_by") or session_data.get("uid") or session_data.get("creator_id"),
+            created_by=session_data.get("created_by")
+            or session_data.get("uid")
+            or session_data.get("creator_id"),
             shared_by=config.uid,  # Current user is the importer
         )
 
@@ -833,7 +843,11 @@ def generate_content_hash(messages: List[Dict]) -> str:
 
 
 def _download_chunks(
-    backend_url: str, share_id: str, headers: Dict[str, str], total_chunks: int
+    backend_url: str,
+    share_id: str,
+    headers: Dict[str, str],
+    total_chunks: int,
+    cache_buster: Optional[str] = None,
 ) -> str:
     """
     Download data in chunks and combine them.
@@ -854,8 +868,11 @@ def _download_chunks(
             task = progress.add_task("[cyan]Downloading chunks...", total=total_chunks)
 
             for i in range(total_chunks):
+                url = f"{backend_url}/api/share/{share_id}/export?chunk={i}"
+                if cache_buster:
+                    url = f"{url}&cache_bust={cache_buster}"
                 chunk_response = httpx.get(
-                    f"{backend_url}/api/share/{share_id}/export?chunk={i}",
+                    url,
                     headers=headers,
                     timeout=60.0,
                 )
@@ -876,8 +893,11 @@ def _download_chunks(
         for i in range(total_chunks):
             print(f"Downloading chunk {i + 1}/{total_chunks}...")
 
+            url = f"{backend_url}/api/share/{share_id}/export?chunk={i}"
+            if cache_buster:
+                url = f"{url}&cache_bust={cache_buster}"
             chunk_response = httpx.get(
-                f"{backend_url}/api/share/{share_id}/export?chunk={i}",
+                url,
                 headers=headers,
                 timeout=60.0,
             )

realign/commands/init.py

@@ -836,6 +836,22 @@ def init_command(
     console.print(f"  Tmux: [cyan]{result.get('tmux_conf', 'N/A')}[/cyan]")
     console.print(f"  Skills: [cyan]{result.get('skills_path', 'N/A')}[/cyan]")
 
+    # Codex compatibility note (best-effort).
+    # We rely on the Rust Codex CLI notify hook to avoid expensive polling. If the installed
+    # Codex binary is legacy/unsupported, warn and suggest upgrading.
+    try:
+        from ..codex_hooks.notify_hook_installer import codex_cli_supports_notify_hook
+
+        supported = codex_cli_supports_notify_hook()
+        if supported is False:
+            console.print("\n[yellow]![/yellow] Codex CLI detected but does not support notify hook.")
+            console.print(
+                "[dim]Tip: update to the Rust Codex CLI to enable reliable, event-driven Codex imports (no polling).[/dim]"
+            )
+        # If Codex isn't installed (None), stay silent.
+    except Exception:
+        pass
+
     hooks_installed = result.get("hooks_installed") or []
     if hooks_installed:
         console.print(f"  Hooks: [cyan]{', '.join(hooks_installed)}[/cyan]")