autoglm-gui 0.4.3__py3-none-any.whl → 0.4.7__py3-none-any.whl

AutoGLM_GUI/__init__.py

@@ -0,0 +1,9 @@
+"""AutoGLM-GUI package metadata."""
+
+from importlib import metadata
+
+# Expose package version at runtime; fall back to "unknown" during editable/dev runs
+try:
+    __version__ = metadata.version("autoglm-gui")
+except metadata.PackageNotFoundError:
+    __version__ = "unknown"

AutoGLM_GUI/__main__.py

@@ -8,6 +8,8 @@ import threading
 import time
 import webbrowser
 
+from AutoGLM_GUI import __version__
+
 # Default configuration
 DEFAULT_MODEL_NAME = "autoglm-phone-9b"
 
@@ -128,6 +130,7 @@ def main() -> None:
     import uvicorn
 
     from AutoGLM_GUI import server
+    from AutoGLM_GUI.config import config
 
     # Set model configuration via environment variables (survives reload)
     os.environ["AUTOGLM_BASE_URL"] = args.base_url
@@ -135,17 +138,15 @@ def main() -> None:
     if args.apikey is not None:
         os.environ["AUTOGLM_API_KEY"] = args.apikey
 
-    # Also set directly for non-reload mode
-    server.DEFAULT_BASE_URL = args.base_url
-    server.DEFAULT_MODEL_NAME = args.model
-    if args.apikey is not None:
-        server.DEFAULT_API_KEY = args.apikey
+    # Refresh config from environment variables
+    config.refresh_from_env()
 
     # Display startup banner
     print()
     print("=" * 50)
     print("  AutoGLM-GUI - Phone Agent Web Interface")
     print("=" * 50)
+    print(f"  Version:    {__version__}")
     print()
     print(f"  Server:     http://{args.host}:{args.port}")
     print()

AutoGLM_GUI/api/agents.py

@@ -4,10 +4,8 @@ import json
 
 from fastapi import APIRouter, HTTPException
 from fastapi.responses import StreamingResponse
-from phone_agent import PhoneAgent
-from phone_agent.agent import AgentConfig
-from phone_agent.model import ModelConfig
 
+from AutoGLM_GUI.config import config
 from AutoGLM_GUI.schemas import (
     APIAgentConfig,
     APIModelConfig,
@@ -18,14 +16,14 @@ from AutoGLM_GUI.schemas import (
     StatusResponse,
 )
 from AutoGLM_GUI.state import (
-    DEFAULT_API_KEY,
-    DEFAULT_BASE_URL,
-    DEFAULT_MODEL_NAME,
     agent_configs,
     agents,
     non_blocking_takeover,
 )
 from AutoGLM_GUI.version import APP_VERSION
+from phone_agent import PhoneAgent
+from phone_agent.agent import AgentConfig
+from phone_agent.model import ModelConfig
 
 router = APIRouter()
 
@@ -41,10 +39,11 @@ def init_agent(request: InitRequest) -> dict:
         raise HTTPException(
             status_code=400, detail="device_id is required in agent_config"
         )
+    config.refresh_from_env()
 
-    base_url = req_model_config.base_url or DEFAULT_BASE_URL
-    api_key = req_model_config.api_key or DEFAULT_API_KEY
-    model_name = req_model_config.model_name or DEFAULT_MODEL_NAME
+    base_url = req_model_config.base_url or config.base_url
+    api_key = req_model_config.api_key or config.api_key
+    model_name = req_model_config.model_name or config.model_name
 
     if not base_url:
         raise HTTPException(

AutoGLM_GUI/api/media.py

@@ -68,7 +68,10 @@ def take_screenshot(request: ScreenshotRequest) -> ScreenshotResponse:
 
 
 @router.websocket("/api/video/stream")
-async def video_stream_ws(websocket: WebSocket, device_id: str | None = None):
+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()
 
@@ -78,6 +81,20 @@ async def video_stream_ws(websocket: WebSocket, device_id: str | None = None):
 
     print(f"[video/stream] WebSocket connection for device {device_id}")
 
+    # Debug: Save stream to file for analysis
+    # Set to True for debugging (default: False)
+    debug_save = False
+    debug_file = None
+    if debug_save:
+        import os
+        from pathlib import Path
+
+        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")
+        print(f"[video/stream] DEBUG: Saving stream to {debug_file_path}")
+
     if device_id not in scrcpy_locks:
         scrcpy_locks[device_id] = asyncio.Lock()
 
@@ -92,6 +109,54 @@ async def video_stream_ws(websocket: WebSocket, device_id: str | None = None):
                 print(f"[video/stream] Starting scrcpy server for device {device_id}")
                 await scrcpy_streamers[device_id].start()
                 print(f"[video/stream] Scrcpy server started for device {device_id}")
+
+                # Read initial chunks and accumulate into a single buffer
+                # Then parse the entire buffer to find complete NAL units
+                streamer = scrcpy_streamers[device_id]
+                accumulated_buffer = bytearray()
+                target_size = 50 * 1024  # Accumulate at least 50KB
+
+                print(f"[video/stream] Accumulating initial data (target: {target_size} bytes)...")
+                for attempt in range(10):
+                    try:
+                        # Disable auto-caching - we'll parse the entire buffer at once
+                        chunk = await streamer.read_h264_chunk(auto_cache=False)
+                        accumulated_buffer.extend(chunk)
+                        print(
+                            f"[video/stream] Read chunk ({len(chunk)} bytes, total: {len(accumulated_buffer)} bytes)"
+                        )
+                    except Exception as e:
+                        print(f"[video/stream] Failed to read chunk: {e}")
+                        await asyncio.sleep(0.5)
+                        continue
+
+                    # Check if we have enough data
+                    if len(accumulated_buffer) >= target_size:
+                        break
+
+                # Now parse the entire accumulated buffer at once
+                # This ensures NAL units spanning multiple chunks are detected as complete
+                print(f"[video/stream] Parsing accumulated buffer ({len(accumulated_buffer)} bytes)...")
+                streamer._cache_nal_units(bytes(accumulated_buffer))
+
+                # Get initialization data
+                init_data = streamer.get_initialization_data()
+                if not init_data:
+                    raise RuntimeError(
+                        f"Failed to find complete SPS/PPS/IDR in {len(accumulated_buffer)} bytes"
+                    )
+
+                # Send initialization data to first client
+                await websocket.send_bytes(init_data)
+                print(
+                    f"[video/stream] Sent initial data ({len(init_data)} bytes) to first client"
+                )
+
+                # Debug: Save to file
+                if debug_file:
+                    debug_file.write(init_data)
+                    debug_file.flush()
+
             except Exception as e:
                 import traceback
 
@@ -108,15 +173,39 @@ async def video_stream_ws(websocket: WebSocket, device_id: str | None = None):
             print(f"[video/stream] Reusing streamer for device {device_id}")
 
             streamer = scrcpy_streamers[device_id]
-            if streamer.cached_sps and streamer.cached_pps:
-                init_data = streamer.cached_sps + streamer.cached_pps
+            # 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
+                print(
+                    f"[video/stream] Waiting for initialization data (attempt {attempt + 1}/10)..."
+                )
+                await asyncio.sleep(0.5)
+
+            if init_data:
                 await websocket.send_bytes(init_data)
-                print(f"[video/stream] Sent SPS/PPS for device {device_id}")
-            else:
                 print(
-                    f"[video/stream] Warning: No cached SPS/PPS for device {device_id}"
+                    f"[video/stream] Sent initialization data (SPS+PPS+IDR, {len(init_data)} bytes) for device {device_id}"
                 )
 
+                # 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"
+                print(f"[video/stream] ERROR: {error_msg}")
+                try:
+                    await websocket.send_json({"error": error_msg})
+                except Exception:
+                    pass
+                return
+
     streamer = scrcpy_streamers[device_id]
 
     stream_failed = False
@@ -124,8 +213,16 @@ async def video_stream_ws(websocket: WebSocket, device_id: str | None = None):
         chunk_count = 0
         while True:
             try:
-                h264_chunk = await streamer.read_h264_chunk()
+                # Disable auto_cache - we only cache once during initialization
+                # Later chunks may have incomplete NAL units that would corrupt the cache
+                h264_chunk = await streamer.read_h264_chunk(auto_cache=False)
                 await websocket.send_bytes(h264_chunk)
+
+                # Debug: Save to file
+                if debug_file:
+                    debug_file.write(h264_chunk)
+                    debug_file.flush()
+
                 chunk_count += 1
                 if chunk_count % 100 == 0:
                     print(
@@ -160,4 +257,9 @@ async def video_stream_ws(websocket: WebSocket, device_id: str | None = None):
                 scrcpy_streamers[device_id].stop()
                 del scrcpy_streamers[device_id]
 
+    # Debug: Close file
+    if debug_file:
+        debug_file.close()
+        print(f"[video/stream] DEBUG: Closed debug file")
+
     print(f"[video/stream] Device {device_id}: Stream ended")

AutoGLM_GUI/config.py

@@ -0,0 +1,23 @@
+"""Application configuration singleton."""
+
+import os
+from dataclasses import dataclass
+
+
+@dataclass
+class AppConfig:
+    """Global application configuration."""
+
+    base_url: str = ""
+    model_name: str = "autoglm-phone-9b"
+    api_key: str = "EMPTY"
+
+    def refresh_from_env(self):
+        """从环境变量刷新配置（适用于 reload 模式）"""
+        self.base_url = os.getenv("AUTOGLM_BASE_URL", self.base_url)
+        self.model_name = os.getenv("AUTOGLM_MODEL_NAME", self.model_name)
+        self.api_key = os.getenv("AUTOGLM_API_KEY", self.api_key)
+
+
+# Global singleton instance
+config = AppConfig()

AutoGLM_GUI/scrcpy_stream.py

@@ -307,11 +307,14 @@ class ScrcpyStreamer:
 
         raise ConnectionError("Failed to connect to scrcpy server")
 
-    def _find_nal_units(self, data: bytes) -> list[tuple[int, int, int]]:
+    def _find_nal_units(
+        self, data: bytes
+    ) -> list[tuple[int, int, int, bool]]:
         """Find NAL units in H.264 data.
 
         Returns:
-            List of (start_pos, nal_type, nal_size) tuples
+            List of (start_pos, nal_type, nal_size, is_complete) tuples
+            is_complete=False if NAL unit extends to chunk boundary (may be truncated)
         """
         nal_units = []
         i = 0
@@ -336,18 +339,22 @@ class ScrcpyStreamer:
 
             # Find next start code to determine NAL unit size
             next_start = nal_start + 1
+            found_next = False
             while next_start < data_len - 3:
                 if (
                     data[next_start : next_start + 4] == b"\x00\x00\x00\x01"
                     or data[next_start : next_start + 3] == b"\x00\x00\x01"
                 ):
+                    found_next = True
                     break
                 next_start += 1
             else:
                 next_start = data_len
 
             nal_size = next_start - i
-            nal_units.append((i, nal_type, nal_size))
+            # NAL unit is complete only if we found the next start code
+            is_complete = found_next
+            nal_units.append((i, nal_type, nal_size, is_complete))
 
             i = next_start
 
@@ -356,13 +363,13 @@ class ScrcpyStreamer:
     def _cache_nal_units(self, data: bytes) -> None:
         """Parse and cache INITIAL complete NAL units (SPS, PPS, IDR).
 
-        IMPORTANT: Only caches complete SPS/PPS from stream start.
-        NAL units may be truncated across chunks, so we validate minimum sizes
-        and lock the cache after getting complete initial parameters.
+        IMPORTANT: Caches NAL units with size validation.
+        For small NAL units (SPS/PPS), we cache even if at chunk boundary.
+        For large NAL units (IDR), we require minimum size to ensure completeness.
         """
         nal_units = self._find_nal_units(data)
 
-        for start, nal_type, size in nal_units:
+        for start, nal_type, size, is_complete in nal_units:
             nal_data = data[start : start + size]
 
             if nal_type == 7:  # SPS
@@ -375,11 +382,11 @@ class ScrcpyStreamer:
                             f"{b:02x}" for b in nal_data[: min(12, len(nal_data))]
                         )
                         print(
-                            f"[ScrcpyStreamer] ✓ Cached complete SPS ({size} bytes): {hex_preview}..."
+                            f"[ScrcpyStreamer] ✓ Cached SPS ({size} bytes, complete={is_complete}): {hex_preview}..."
                         )
                     elif size < 10:
                         print(
-                            f"[ScrcpyStreamer] ✗ Skipped truncated SPS ({size} bytes, too short)"
+                            f"[ScrcpyStreamer] ✗ Skipped short SPS ({size} bytes)"
                         )
 
             elif nal_type == 8:  # PPS
@@ -392,24 +399,33 @@ class ScrcpyStreamer:
                             f"{b:02x}" for b in nal_data[: min(12, len(nal_data))]
                         )
                         print(
-                            f"[ScrcpyStreamer] ✓ Cached complete PPS ({size} bytes): {hex_preview}..."
+                            f"[ScrcpyStreamer] ✓ Cached PPS ({size} bytes, complete={is_complete}): {hex_preview}..."
                         )
                     elif size < 6:
                         print(
-                            f"[ScrcpyStreamer] ✗ Skipped truncated PPS ({size} bytes, too short)"
+                            f"[ScrcpyStreamer] ✗ Skipped short PPS ({size} bytes)"
                         )
 
             elif nal_type == 5:  # IDR frame
-                # ✅ ALWAYS update IDR to keep the LATEST frame
-                # This gives better UX on reconnect (recent content, not stale startup frame)
-                if self.cached_sps and self.cached_pps:
+                # CRITICAL: Only cache COMPLETE IDR frames
+                # Incomplete IDR frames cause "error while decoding MB" errors
+                if self.cached_sps and self.cached_pps and is_complete and size >= 1024:
                     is_first = self.cached_idr is None
                     self.cached_idr = nal_data
                     if is_first:
                         print(
-                            f"[ScrcpyStreamer] ✓ Cached initial IDR frame ({size} bytes)"
+                            f"[ScrcpyStreamer] ✓ Cached COMPLETE IDR frame ({size} bytes)"
                         )
                     # Don't log every IDR update (too verbose)
+                elif not is_complete:
+                    if size > 1024:  # Only log if it's a large incomplete IDR
+                        print(
+                            f"[ScrcpyStreamer] ⚠ Skipped INCOMPLETE IDR ({size} bytes, extends to chunk boundary)"
+                        )
+                elif size < 1024:
+                    print(
+                        f"[ScrcpyStreamer] ✗ Skipped small IDR ({size} bytes)"
+                    )
 
         # Lock SPS/PPS once we have complete initial parameters
         if self.cached_sps and self.cached_pps and not self.sps_pps_locked:
@@ -435,7 +451,9 @@ class ScrcpyStreamer:
 
         # Find all IDR frames
         idr_positions = [
-            (start, size) for start, nal_type, size in nal_units if nal_type == 5
+            (start, size)
+            for start, nal_type, size, _ in nal_units
+            if nal_type == 5
         ]
 
         if not idr_positions:
@@ -497,11 +515,14 @@ class ScrcpyStreamer:
             return init_data
         return None
 
-    async def read_h264_chunk(self) -> bytes:
+    async def read_h264_chunk(self, auto_cache: bool = True) -> bytes:
         """Read H.264 data chunk from socket.
 
+        Args:
+            auto_cache: If True, automatically cache SPS/PPS/IDR from this chunk
+
         Returns:
-            bytes: Raw H.264 data with SPS/PPS prepended to IDR frames
+            bytes: Raw H.264 data
 
         Raises:
             ConnectionError: If socket is closed or error occurs
@@ -524,9 +545,9 @@ class ScrcpyStreamer:
                     f"[ScrcpyStreamer] Large chunk received: {len(data) / 1024:.1f} KB"
                 )
 
-            # Cache INITIAL complete SPS/PPS/IDR for future use
-            # (Later chunks may have truncated NAL units, so we only cache once)
-            self._cache_nal_units(data)
+            # Optionally cache SPS/PPS/IDR from this chunk
+            if auto_cache:
+                self._cache_nal_units(data)
 
             # NOTE: We don't automatically prepend SPS/PPS here because:
             # 1. NAL units may be truncated across chunks

AutoGLM_GUI/state.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import asyncio
-import os
 from typing import TYPE_CHECKING
 
 from phone_agent.agent import AgentConfig
@@ -22,11 +21,6 @@ agent_configs: dict[str, tuple[ModelConfig, AgentConfig]] = {}
 scrcpy_streamers: dict[str, "ScrcpyStreamer"] = {}
 scrcpy_locks: dict[str, asyncio.Lock] = {}
 
-# Defaults pulled from env (used when request omits config)
-DEFAULT_BASE_URL: str = os.getenv("AUTOGLM_BASE_URL", "")
-DEFAULT_MODEL_NAME: str = os.getenv("AUTOGLM_MODEL_NAME", "autoglm-phone-9b")
-DEFAULT_API_KEY: str = os.getenv("AUTOGLM_API_KEY", "EMPTY")
-
 
 def non_blocking_takeover(message: str) -> None:
     """Log takeover requests without blocking for console input."""

AutoGLM_GUI/static/assets/{about-B8Uhchgz.js → about-DIdU3ZqP.js}

@@ -1 +1 @@
-import{j as o}from"./index-CVkp0My_.js";function t(){return o.jsx("div",{className:"p-2",children:o.jsx("h3",{children:"About"})})}export{t as component};
+import{j as o}from"./index--ElIPD22.js";function t(){return o.jsx("div",{className:"p-2",children:o.jsx("h3",{children:"About"})})}export{t as component};