autoglm-gui 0.4.11__py3-none-any.whl → 0.4.13__py3-none-any.whl

AutoGLM_GUI/api/media.py

@@ -1,52 +1,28 @@
-"""Media routes: screenshot, video stream, stream reset."""
+"""Media routes: screenshot and stream reset."""
 
-import asyncio
-import os
-from pathlib import Path
+from __future__ import annotations
 
-from fastapi import APIRouter, WebSocket, WebSocketDisconnect
+from fastapi import APIRouter
 
 from AutoGLM_GUI.adb_plus import capture_screenshot
 from AutoGLM_GUI.logger import logger
 from AutoGLM_GUI.schemas import ScreenshotRequest, ScreenshotResponse
-from AutoGLM_GUI.scrcpy_stream import ScrcpyStreamer
-from AutoGLM_GUI.state import scrcpy_locks, scrcpy_streamers
+from AutoGLM_GUI.socketio_server import stop_streamers
 
 router = APIRouter()
 
-# Debug configuration: Set DEBUG_SAVE_VIDEO_STREAM=1 to save streams to debug_streams/
-DEBUG_SAVE_STREAM = os.getenv("DEBUG_SAVE_VIDEO_STREAM", "0") == "1"
-
 
 @router.post("/api/video/reset")
 async def reset_video_stream(device_id: str | None = None) -> dict:
-    """Reset video stream (cleanup scrcpy server，多设备支持)."""
+    """Reset active scrcpy streams (Socket.IO)."""
+    stop_streamers(device_id=device_id)
     if device_id:
-        if device_id in scrcpy_locks:
-            async with scrcpy_locks[device_id]:
-                if device_id in scrcpy_streamers:
-                    logger.info(f"Stopping streamer for device {device_id}")
-                    scrcpy_streamers[device_id].stop()
-                    del scrcpy_streamers[device_id]
-                    logger.info(f"Streamer reset for device {device_id}")
-                    return {
-                        "success": True,
-                        "message": f"Video stream reset for device {device_id}",
-                    }
-                return {
-                    "success": True,
-                    "message": f"No active video stream for device {device_id}",
-                }
-        return {"success": True, "message": f"No video stream for device {device_id}"}
-
-    device_ids = list(scrcpy_streamers.keys())
-    for dev_id in device_ids:
-        if dev_id in scrcpy_locks:
-            async with scrcpy_locks[dev_id]:
-                if dev_id in scrcpy_streamers:
-                    scrcpy_streamers[dev_id].stop()
-                    del scrcpy_streamers[dev_id]
-    logger.info("All streamers reset")
+        logger.info("Video stream reset for device %s", device_id)
+        return {
+            "success": True,
+            "message": f"Video stream reset for device {device_id}",
+        }
+    logger.info("All video streams reset")
     return {"success": True, "message": "All video streams reset"}
 
 
@@ -71,202 +47,3 @@ def take_screenshot(request: ScreenshotRequest) -> ScreenshotResponse:
             is_sensitive=False,
             error=str(e),
         )
-
-
-@router.websocket("/api/video/stream")
-async def video_stream_ws(
-    websocket: WebSocket,
-    device_id: str | None = None,
-):
-    """Stream real-time H.264 video from scrcpy server via WebSocket（多设备支持）."""
-    await websocket.accept()
-
-    if not device_id:
-        await websocket.send_json({"error": "device_id is required"})
-        return
-
-    logger.info(f"WebSocket connection for device {device_id}")
-
-    # Debug: Save stream to file for analysis (controlled by DEBUG_SAVE_VIDEO_STREAM env var)
-    debug_file = None
-    if DEBUG_SAVE_STREAM:
-        debug_dir = Path("debug_streams")
-        debug_dir.mkdir(exist_ok=True)
-        debug_file_path = (
-            debug_dir / f"{device_id}_{int(__import__('time').time())}.h264"
-        )
-        debug_file = open(debug_file_path, "wb")
-        logger.debug(f"DEBUG: Saving stream to {debug_file_path}")
-
-    if device_id not in scrcpy_locks:
-        scrcpy_locks[device_id] = asyncio.Lock()
-
-    async with scrcpy_locks[device_id]:
-        if device_id not in scrcpy_streamers:
-            logger.info(f"Creating streamer for device {device_id}")
-            scrcpy_streamers[device_id] = ScrcpyStreamer(
-                device_id=device_id, max_size=1280, bit_rate=4_000_000
-            )
-
-            try:
-                logger.info(f"Starting scrcpy server for device {device_id}")
-                await scrcpy_streamers[device_id].start()
-                logger.info(f"Scrcpy server started for device {device_id}")
-
-                # Read NAL units until we have SPS, PPS, and IDR
-                streamer = scrcpy_streamers[device_id]
-
-                logger.debug("Reading NAL units for initialization...")
-                for attempt in range(20):  # Max 20 NAL units for initialization
-                    try:
-                        nal_unit = await streamer.read_nal_unit(auto_cache=True)
-                        nal_type = nal_unit[4] & 0x1F if len(nal_unit) > 4 else -1
-                        nal_type_names = {5: "IDR", 7: "SPS", 8: "PPS"}
-                        logger.debug(
-                            f"Read NAL unit: type={nal_type_names.get(nal_type, nal_type)}, size={len(nal_unit)} bytes"
-                        )
-
-                        # Check if we have all required parameter sets
-                        if (
-                            streamer.cached_sps
-                            and streamer.cached_pps
-                            and streamer.cached_idr
-                        ):
-                            logger.debug(
-                                f"✓ Initialization complete: SPS={len(streamer.cached_sps)}B, PPS={len(streamer.cached_pps)}B, IDR={len(streamer.cached_idr)}B"
-                            )
-                            break
-                    except Exception as e:
-                        logger.warning(f"Failed to read NAL unit: {e}")
-                        await asyncio.sleep(0.5)
-                        continue
-
-                # Get initialization data (SPS + PPS + IDR)
-                init_data = streamer.get_initialization_data()
-                if not init_data:
-                    raise RuntimeError(
-                        "Failed to get initialization data (missing SPS/PPS/IDR)"
-                    )
-
-                # Send initialization data as ONE message (SPS+PPS+IDR combined)
-                await websocket.send_bytes(init_data)
-                logger.debug(
-                    f"✓ Sent initialization data to first client: {len(init_data)} bytes total"
-                )
-
-                # Debug: Save to file
-                if debug_file:
-                    debug_file.write(init_data)
-                    debug_file.flush()
-
-            except Exception as e:
-                logger.exception(f"Failed to start streamer: {e}")
-                scrcpy_streamers[device_id].stop()
-                del scrcpy_streamers[device_id]
-                try:
-                    await websocket.send_json({"error": str(e)})
-                except Exception:
-                    pass
-                return
-        else:
-            logger.info(f"Reusing streamer for device {device_id}")
-
-            streamer = scrcpy_streamers[device_id]
-            # CRITICAL: Send complete initialization data (SPS+PPS+IDR)
-            # Without IDR frame, decoder cannot start and will show black screen
-
-            # Wait for initialization data to be ready (max 5 seconds)
-            init_data = None
-            for attempt in range(10):
-                init_data = streamer.get_initialization_data()
-                if init_data:
-                    break
-                logger.debug(
-                    f"Waiting for initialization data (attempt {attempt + 1}/10)..."
-                )
-                await asyncio.sleep(0.5)
-
-            if init_data:
-                # Log what we're sending
-                logger.debug(
-                    f"✓ Sending cached initialization data for device {device_id}:"
-                )
-                logger.debug(
-                    f"  - SPS: {len(streamer.cached_sps) if streamer.cached_sps else 0}B"
-                )
-                logger.debug(
-                    f"  - PPS: {len(streamer.cached_pps) if streamer.cached_pps else 0}B"
-                )
-                logger.debug(
-                    f"  - IDR: {len(streamer.cached_idr) if streamer.cached_idr else 0}B"
-                )
-                logger.debug(f"  - Total: {len(init_data)} bytes")
-
-                await websocket.send_bytes(init_data)
-                logger.debug("✓ Initialization data sent successfully")
-
-                # Debug: Save to file
-                if debug_file:
-                    debug_file.write(init_data)
-                    debug_file.flush()
-            else:
-                error_msg = f"Initialization data not ready for device {device_id} after 5 seconds"
-                logger.error(f"ERROR: {error_msg}")
-                try:
-                    await websocket.send_json({"error": error_msg})
-                except Exception:
-                    pass
-                return
-
-    streamer = scrcpy_streamers[device_id]
-
-    stream_failed = False
-    try:
-        nal_count = 0
-        while True:
-            try:
-                # Read one complete NAL unit
-                # Each WebSocket message = one complete NAL unit (clear semantic boundary)
-                nal_unit = await streamer.read_nal_unit(auto_cache=True)
-                await websocket.send_bytes(nal_unit)
-
-                # Debug: Save to file
-                if debug_file:
-                    debug_file.write(nal_unit)
-                    debug_file.flush()
-
-                nal_count += 1
-                if nal_count % 100 == 0:
-                    logger.debug(f"Device {device_id}: Sent {nal_count} NAL units")
-            except ConnectionError as e:
-                logger.warning(f"Device {device_id}: Connection error: {e}")
-                stream_failed = True
-                try:
-                    await websocket.send_json({"error": f"Stream error: {str(e)}"})
-                except Exception:
-                    pass
-                break
-
-    except WebSocketDisconnect:
-        logger.info(f"Device {device_id}: Client disconnected")
-    except Exception as e:
-        logger.exception(f"Device {device_id}: Error: {e}")
-        stream_failed = True
-        try:
-            await websocket.send_json({"error": str(e)})
-        except Exception:
-            pass
-
-    if stream_failed:
-        async with scrcpy_locks[device_id]:
-            if device_id in scrcpy_streamers:
-                logger.info(f"Resetting streamer for device {device_id}")
-                scrcpy_streamers[device_id].stop()
-                del scrcpy_streamers[device_id]
-
-    # Debug: Close file
-    if debug_file:
-        debug_file.close()
-        logger.debug("DEBUG: Closed debug file")
-
-    logger.info(f"Device {device_id}: Stream ended")

AutoGLM_GUI/api/version.py

@@ -0,0 +1,192 @@
+"""Version check API for detecting updates from GitHub Releases."""
+
+import json
+import re
+import time
+import urllib.request
+from typing import Any
+
+from fastapi import APIRouter
+
+from AutoGLM_GUI.logger import logger
+from AutoGLM_GUI.schemas import VersionCheckResponse
+from AutoGLM_GUI.version import APP_VERSION
+
+router = APIRouter()
+
+# In-memory cache for version check results
+_version_cache: dict[str, Any] = {
+    "data": None,
+    "timestamp": 0,
+    "ttl": 3600,  # 1 hour cache TTL
+}
+
+# GitHub repository information
+GITHUB_REPO = "suyiiyii/AutoGLM-GUI"
+GITHUB_API_URL = f"https://api.github.com/repos/{GITHUB_REPO}/releases/latest"
+
+
+def parse_version(version_str: str) -> tuple[int, ...] | None:
+    """
+    Parse semantic version string into tuple of integers.
+
+    Args:
+        version_str: Version string like "0.4.12" or "v0.5.0"
+
+    Returns:
+        Tuple of version numbers like (0, 4, 12) or None if invalid
+    """
+    # Handle dev/unknown versions
+    if version_str in ("dev", "unknown", "..."):
+        return None
+
+    # Strip 'v' prefix if present
+    version_str = version_str.lstrip("v")
+
+    # Remove pre-release tags (e.g., "-beta", "-rc1")
+    version_str = re.split(r"[-+]", version_str)[0]
+
+    try:
+        return tuple(int(x) for x in version_str.split("."))
+    except (ValueError, AttributeError):
+        logger.warning(f"Failed to parse version: {version_str}")
+        return None
+
+
+def compare_versions(current: str, latest: str) -> bool:
+    """
+    Compare two semantic versions.
+
+    Args:
+        current: Current version string
+        latest: Latest version string
+
+    Returns:
+        True if update is available (latest > current), False otherwise
+    """
+    current_tuple = parse_version(current)
+    latest_tuple = parse_version(latest)
+
+    # If either version is invalid, assume no update
+    if current_tuple is None or latest_tuple is None:
+        return False
+
+    return latest_tuple > current_tuple
+
+
+def fetch_latest_release() -> dict[str, Any] | None:
+    """
+    Fetch latest release information from GitHub API.
+
+    Returns:
+        Release data dict with 'tag_name', 'html_url', 'published_at' or None on error
+    """
+    try:
+        # Create request with User-Agent header (required by GitHub API)
+        req = urllib.request.Request(
+            GITHUB_API_URL,
+            headers={"User-Agent": f"AutoGLM-GUI/{APP_VERSION}"},
+        )
+
+        # Fetch data with 10-second timeout
+        with urllib.request.urlopen(req, timeout=10) as response:
+            data = json.loads(response.read().decode("utf-8"))
+            logger.debug(
+                f"Successfully fetched latest release: {data.get('tag_name', 'unknown')}"
+            )
+            return data
+
+    except urllib.error.HTTPError as e:
+        if e.code == 403:
+            logger.warning(
+                "GitHub API rate limit exceeded (HTTP 403), using cached data if available"
+            )
+        else:
+            logger.warning(f"GitHub API HTTP error {e.code}: {e.reason}")
+        return None
+
+    except urllib.error.URLError as e:
+        logger.warning(f"Network error fetching latest release: {e.reason}")
+        return None
+
+    except json.JSONDecodeError as e:
+        logger.error(f"Failed to parse GitHub API response: {e}")
+        return None
+
+    except Exception as e:
+        logger.error(f"Unexpected error fetching latest release: {e}")
+        return None
+
+
+@router.get("/api/version/latest", response_model=VersionCheckResponse)
+def check_version() -> VersionCheckResponse:
+    """
+    Check for available updates from GitHub Releases.
+
+    Returns version comparison results with caching to minimize API calls.
+    Cache TTL is 1 hour to stay within GitHub API rate limits (60 req/hour).
+
+    Returns:
+        VersionCheckResponse with update information
+    """
+    current_time = time.time()
+
+    # Check if cache is still valid
+    if (
+        _version_cache["data"] is not None
+        and current_time - _version_cache["timestamp"] < _version_cache["ttl"]
+    ):
+        logger.debug(
+            f"Using cached version check result (age: {int(current_time - _version_cache['timestamp'])}s)"
+        )
+        return _version_cache["data"]
+
+    # Fetch latest release from GitHub
+    release_data = fetch_latest_release()
+
+    if release_data is None:
+        # If fetch failed, check if we have cached data to fall back to
+        if _version_cache["data"] is not None:
+            logger.warning("Using stale cached data due to fetch failure")
+            return _version_cache["data"]
+
+        # No cache available, return safe defaults
+        response = VersionCheckResponse(
+            current_version=APP_VERSION,
+            latest_version=None,
+            has_update=False,
+            release_url=None,
+            published_at=None,
+            error="Failed to fetch latest version from GitHub",
+        )
+        logger.info("Version check failed, returning safe defaults")
+        return response
+
+    # Extract version information from release data
+    tag_name = release_data.get("tag_name", "")
+    latest_version = tag_name.lstrip("v")  # Strip 'v' prefix
+    release_url = release_data.get("html_url")
+    published_at = release_data.get("published_at")
+
+    # Compare versions
+    has_update = compare_versions(APP_VERSION, latest_version)
+
+    # Build response
+    response = VersionCheckResponse(
+        current_version=APP_VERSION,
+        latest_version=latest_version,
+        has_update=has_update,
+        release_url=release_url,
+        published_at=published_at,
+        error=None,
+    )
+
+    # Update cache
+    _version_cache["data"] = response
+    _version_cache["timestamp"] = current_time
+
+    logger.info(
+        f"Version check completed: current={APP_VERSION}, latest={latest_version}, has_update={has_update}"
+    )
+
+    return response