autoglm-gui 0.4.7__tar.gz → 0.4.9__tar.gz

autoglm_gui-0.4.9/AutoGLM_GUI/__init__.py

@@ -0,0 +1,52 @@
+"""AutoGLM-GUI package metadata."""
+
+import subprocess
+import sys
+from functools import wraps
+from importlib import metadata
+
+# ============================================================================
+# Fix Windows encoding issue: Force UTF-8 for all subprocess calls
+# ============================================================================
+# On Windows, subprocess defaults to GBK encoding which fails when ADB/scrcpy
+# output UTF-8 characters. This monkey patch ensures all subprocess calls
+# use UTF-8 encoding by default.
+
+_original_run = subprocess.run
+_original_popen = subprocess.Popen
+
+
+@wraps(_original_run)
+def _patched_run(*args, **kwargs):
+    """Patched subprocess.run that defaults to UTF-8 encoding on Windows."""
+    if sys.platform == "win32":
+        # Add encoding='utf-8' if text=True is set but encoding is not specified
+        if kwargs.get("text") or kwargs.get("universal_newlines"):
+            if "encoding" not in kwargs:
+                kwargs["encoding"] = "utf-8"
+    return _original_run(*args, **kwargs)
+
+
+class _PatchedPopen(_original_popen):
+    """Patched subprocess.Popen that defaults to UTF-8 encoding on Windows."""
+
+    def __init__(self, *args, **kwargs):
+        if sys.platform == "win32":
+            # Add encoding='utf-8' if text=True is set but encoding is not specified
+            if kwargs.get("text") or kwargs.get("universal_newlines"):
+                if "encoding" not in kwargs:
+                    kwargs["encoding"] = "utf-8"
+        super().__init__(*args, **kwargs)
+
+
+# Apply the patches globally
+subprocess.run = _patched_run
+subprocess.Popen = _PatchedPopen
+
+# ============================================================================
+
+# 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-0.4.7 → autoglm_gui-0.4.9}/AutoGLM_GUI/api/media.py

@@ -1,6 +1,8 @@
 """Media routes: screenshot, video stream, stream reset."""
 
 import asyncio
+import os
+from pathlib import Path
 
 from fastapi import APIRouter, WebSocket, WebSocketDisconnect
 
@@ -11,6 +13,9 @@ from AutoGLM_GUI.state import scrcpy_locks, scrcpy_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:
@@ -81,17 +86,14 @@ async def video_stream_ws(
 
     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: Save stream to file for analysis (controlled by DEBUG_SAVE_VIDEO_STREAM env var)
     debug_file = None
-    if debug_save:
-        import os
-        from pathlib import Path
-
+    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_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}")
 
@@ -110,46 +112,45 @@ async def video_stream_ws(
                 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
+                # Read NAL units until we have SPS, PPS, and IDR
                 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):
+                print("[video/stream] Reading NAL units for initialization...")
+                for attempt in range(20):  # Max 20 NAL units for initialization
                     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)
+                        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"}
                         print(
-                            f"[video/stream] Read chunk ({len(chunk)} bytes, total: {len(accumulated_buffer)} bytes)"
+                            f"[video/stream] 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
+                        ):
+                            print(
+                                f"[video/stream] ✓ 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:
-                        print(f"[video/stream] Failed to read chunk: {e}")
+                        print(f"[video/stream] Failed to read NAL unit: {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
+                # Get initialization data (SPS + PPS + IDR)
                 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"
+                        "Failed to get initialization data (missing SPS/PPS/IDR)"
                     )
 
-                # Send initialization data to first client
+                # Send initialization data as ONE message (SPS+PPS+IDR combined)
                 await websocket.send_bytes(init_data)
                 print(
-                    f"[video/stream] Sent initial data ({len(init_data)} bytes) to first client"
+                    f"[video/stream] ✓ Sent initialization data to first client: {len(init_data)} bytes total"
                 )
 
                 # Debug: Save to file
@@ -188,10 +189,23 @@ async def video_stream_ws(
                 await asyncio.sleep(0.5)
 
             if init_data:
-                await websocket.send_bytes(init_data)
+                # Log what we're sending
                 print(
-                    f"[video/stream] Sent initialization data (SPS+PPS+IDR, {len(init_data)} bytes) for device {device_id}"
+                    f"[video/stream] ✓ Sending cached initialization data for device {device_id}:"
                 )
+                print(
+                    f"  - SPS: {len(streamer.cached_sps) if streamer.cached_sps else 0}B"
+                )
+                print(
+                    f"  - PPS: {len(streamer.cached_pps) if streamer.cached_pps else 0}B"
+                )
+                print(
+                    f"  - IDR: {len(streamer.cached_idr) if streamer.cached_idr else 0}B"
+                )
+                print(f"  - Total: {len(init_data)} bytes")
+
+                await websocket.send_bytes(init_data)
+                print("[video/stream] ✓ Initialization data sent successfully")
 
                 # Debug: Save to file
                 if debug_file:
@@ -210,23 +224,23 @@ async def video_stream_ws(
 
     stream_failed = False
     try:
-        chunk_count = 0
+        nal_count = 0
         while True:
             try:
-                # 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)
+                # 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(h264_chunk)
+                    debug_file.write(nal_unit)
                     debug_file.flush()
 
-                chunk_count += 1
-                if chunk_count % 100 == 0:
+                nal_count += 1
+                if nal_count % 100 == 0:
                     print(
-                        f"[video/stream] Device {device_id}: Sent {chunk_count} chunks"
+                        f"[video/stream] Device {device_id}: Sent {nal_count} NAL units"
                     )
             except ConnectionError as e:
                 print(f"[video/stream] Device {device_id}: Connection error: {e}")
@@ -260,6 +274,6 @@ async def video_stream_ws(
     # Debug: Close file
     if debug_file:
         debug_file.close()
-        print(f"[video/stream] DEBUG: Closed debug file")
+        print("[video/stream] DEBUG: Closed debug file")
 
     print(f"[video/stream] Device {device_id}: Stream ended")

autoglm_gui-0.4.9/AutoGLM_GUI/platform_utils.py

@@ -0,0 +1,37 @@
+"""Platform-aware subprocess helpers to avoid duplicated Windows branches."""
+
+import asyncio
+import platform
+import subprocess
+from typing import Any, Sequence
+
+
+def is_windows() -> bool:
+    """Return True if running on Windows."""
+    return platform.system() == "Windows"
+
+
+async def run_cmd_silently(cmd: Sequence[str]) -> subprocess.CompletedProcess:
+    """Run a command, suppressing output; safe for async contexts on all platforms."""
+    if is_windows():
+        # Avoid blocking the event loop with a blocking subprocess call on Windows.
+        return await asyncio.to_thread(
+            subprocess.run, cmd, capture_output=True, check=False
+        )
+
+    process = await asyncio.create_subprocess_exec(
+        *cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
+    )
+    await process.wait()
+    return subprocess.CompletedProcess(cmd, process.returncode, None, None)
+
+
+async def spawn_process(cmd: Sequence[str], *, capture_output: bool = False) -> Any:
+    """Start a long-running process with optional stdio capture."""
+    stdout = subprocess.PIPE if capture_output else None
+    stderr = subprocess.PIPE if capture_output else None
+
+    if is_windows():
+        return subprocess.Popen(cmd, stdout=stdout, stderr=stderr)
+
+    return await asyncio.create_subprocess_exec(*cmd, stdout=stdout, stderr=stderr)

{autoglm_gui-0.4.7 → autoglm_gui-0.4.9}/AutoGLM_GUI/scrcpy_stream.py

@@ -2,10 +2,12 @@
 
 import asyncio
 import os
-import platform
 import socket
 import subprocess
 from pathlib import Path
+from typing import Any
+
+from AutoGLM_GUI.platform_utils import is_windows, run_cmd_silently, spawn_process
 
 
 class ScrcpyStreamer:
@@ -34,7 +36,7 @@ class ScrcpyStreamer:
         self.port = port
         self.idr_interval_s = idr_interval_s
 
-        self.scrcpy_process: subprocess.Popen | None = None
+        self.scrcpy_process: Any | None = None
         self.tcp_socket: socket.socket | None = None
         self.forward_cleanup_needed = False
 
@@ -47,6 +49,9 @@ class ScrcpyStreamer:
         self.sps_pps_locked = False  # Lock SPS/PPS after initial complete capture
         # Note: IDR is NOT locked - we keep updating to the latest frame
 
+        # NAL unit reading buffer (for read_nal_unit method)
+        self._nal_read_buffer = bytearray()
+
         # Find scrcpy-server location
         self.scrcpy_server_path = self._find_scrcpy_server()
 
@@ -83,6 +88,10 @@ class ScrcpyStreamer:
 
     async def start(self) -> None:
         """Start scrcpy server and establish connection."""
+        # Clear NAL reading buffer to ensure clean state
+        self._nal_read_buffer.clear()
+        print("[ScrcpyStreamer] Cleared NAL read buffer")
+
         try:
             # 0. Kill existing scrcpy server processes on device
             print("[ScrcpyStreamer] Cleaning up existing scrcpy processes...")
@@ -119,50 +128,20 @@ class ScrcpyStreamer:
         if self.device_id:
             cmd_base.extend(["-s", self.device_id])
 
-        # On Windows, use subprocess.run instead of asyncio.create_subprocess_exec
-        # to avoid NotImplementedError in some Windows environments
-        if platform.system() == "Windows":
-            # Method 1: Try pkill
-            cmd = cmd_base + ["shell", "pkill", "-9", "-f", "app_process.*scrcpy"]
-            subprocess.run(cmd, capture_output=True, check=False)
+        # Method 1: Try pkill
+        cmd = cmd_base + ["shell", "pkill", "-9", "-f", "app_process.*scrcpy"]
+        await run_cmd_silently(cmd)
 
-            # Method 2: Find and kill by PID (more reliable)
-            cmd = cmd_base + [
-                "shell",
-                "ps -ef | grep 'app_process.*scrcpy' | grep -v grep | awk '{print $2}' | xargs kill -9",
-            ]
-            subprocess.run(cmd, capture_output=True, check=False)
-
-            # Method 3: Remove port forward if exists
-            cmd_remove_forward = cmd_base + ["forward", "--remove", f"tcp:{self.port}"]
-            subprocess.run(cmd_remove_forward, capture_output=True, check=False)
-        else:
-            # Original asyncio-based implementation for Unix systems
-            # Method 1: Try pkill
-            cmd = cmd_base + ["shell", "pkill", "-9", "-f", "app_process.*scrcpy"]
-            process = await asyncio.create_subprocess_exec(
-                *cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
-            )
-            await process.wait()
+        # Method 2: Find and kill by PID (more reliable)
+        cmd = cmd_base + [
+            "shell",
+            "ps -ef | grep 'app_process.*scrcpy' | grep -v grep | awk '{print $2}' | xargs kill -9",
+        ]
+        await run_cmd_silently(cmd)
 
-            # Method 2: Find and kill by PID (more reliable)
-            cmd = cmd_base + [
-                "shell",
-                "ps -ef | grep 'app_process.*scrcpy' | grep -v grep | awk '{print $2}' | xargs kill -9",
-            ]
-            process = await asyncio.create_subprocess_exec(
-                *cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
-            )
-            await process.wait()
-
-            # Method 3: Remove port forward if exists
-            cmd_remove_forward = cmd_base + ["forward", "--remove", f"tcp:{self.port}"]
-            process = await asyncio.create_subprocess_exec(
-                *cmd_remove_forward,
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
-            )
-            await process.wait()
+        # Method 3: Remove port forward if exists
+        cmd_remove_forward = cmd_base + ["forward", "--remove", f"tcp:{self.port}"]
+        await run_cmd_silently(cmd_remove_forward)
 
         # Wait longer for resources to be released
         print("[ScrcpyStreamer] Waiting for cleanup to complete...")
@@ -175,13 +154,7 @@ class ScrcpyStreamer:
             cmd.extend(["-s", self.device_id])
         cmd.extend(["push", self.scrcpy_server_path, "/data/local/tmp/scrcpy-server"])
 
-        if platform.system() == "Windows":
-            subprocess.run(cmd, capture_output=True, check=False)
-        else:
-            process = await asyncio.create_subprocess_exec(
-                *cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
-            )
-            await process.wait()
+        await run_cmd_silently(cmd)
 
     async def _setup_port_forward(self) -> None:
         """Setup ADB port forwarding."""
@@ -190,13 +163,7 @@ class ScrcpyStreamer:
             cmd.extend(["-s", self.device_id])
         cmd.extend(["forward", f"tcp:{self.port}", "localabstract:scrcpy"])
 
-        if platform.system() == "Windows":
-            subprocess.run(cmd, capture_output=True, check=False)
-        else:
-            process = await asyncio.create_subprocess_exec(
-                *cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
-            )
-            await process.wait()
+        await run_cmd_silently(cmd)
         self.forward_cleanup_needed = True
 
     async def _start_server(self) -> None:
@@ -231,22 +198,14 @@ class ScrcpyStreamer:
             cmd.extend(server_args)
 
             # Capture stderr to see error messages
-            if platform.system() == "Windows":
-                # On Windows, use subprocess.Popen for async-like behavior
-                self.scrcpy_process = subprocess.Popen(
-                    cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE
-                )
-            else:
-                self.scrcpy_process = await asyncio.create_subprocess_exec(
-                    *cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE
-                )
+            self.scrcpy_process = await spawn_process(cmd, capture_output=True)
 
             # Wait for server to start
             await asyncio.sleep(2)
 
             # Check if process is still running
             error_msg = None
-            if platform.system() == "Windows":
+            if is_windows():
                 # For Windows Popen, check returncode directly
                 if self.scrcpy_process.poll() is not None:
                     # Process has exited
@@ -307,9 +266,7 @@ class ScrcpyStreamer:
 
         raise ConnectionError("Failed to connect to scrcpy server")
 
-    def _find_nal_units(
-        self, data: bytes
-    ) -> list[tuple[int, int, int, bool]]:
+    def _find_nal_units(self, data: bytes) -> list[tuple[int, int, int, bool]]:
         """Find NAL units in H.264 data.
 
         Returns:
@@ -385,9 +342,7 @@ class ScrcpyStreamer:
                             f"[ScrcpyStreamer] ✓ Cached SPS ({size} bytes, complete={is_complete}): {hex_preview}..."
                         )
                     elif size < 10:
-                        print(
-                            f"[ScrcpyStreamer] ✗ Skipped short SPS ({size} bytes)"
-                        )
+                        print(f"[ScrcpyStreamer] ✗ Skipped short SPS ({size} bytes)")
 
             elif nal_type == 8:  # PPS
                 # Only cache PPS if not yet locked
@@ -402,29 +357,22 @@ class ScrcpyStreamer:
                             f"[ScrcpyStreamer] ✓ Cached PPS ({size} bytes, complete={is_complete}): {hex_preview}..."
                         )
                     elif size < 6:
-                        print(
-                            f"[ScrcpyStreamer] ✗ Skipped short PPS ({size} bytes)"
-                        )
+                        print(f"[ScrcpyStreamer] ✗ Skipped short PPS ({size} bytes)")
 
             elif nal_type == 5:  # IDR frame
-                # 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:
+                # Cache IDR if it's large enough (size check is sufficient)
+                # Note: When called from read_nal_unit(), the NAL is guaranteed complete
+                # because we extract it between two start codes. The is_complete flag
+                # is only False because the NAL is isolated (no next start code in buffer).
+                if self.cached_sps and self.cached_pps and size >= 1024:
                     is_first = self.cached_idr is None
                     self.cached_idr = nal_data
                     if is_first:
-                        print(
-                            f"[ScrcpyStreamer] ✓ Cached COMPLETE IDR frame ({size} bytes)"
-                        )
+                        print(f"[ScrcpyStreamer] ✓ Cached 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)"
+                        f"[ScrcpyStreamer] ✗ Skipped small IDR ({size} bytes, likely incomplete)"
                     )
 
         # Lock SPS/PPS once we have complete initial parameters
@@ -432,60 +380,6 @@ class ScrcpyStreamer:
             self.sps_pps_locked = True
             print("[ScrcpyStreamer] 🔒 SPS/PPS locked (IDR will continue updating)")
 
-    def _prepend_sps_pps_to_idr(self, data: bytes) -> bytes:
-        """Prepend SPS/PPS before EVERY IDR frame unconditionally.
-
-        This ensures that clients can start decoding from any IDR frame,
-        even if they join mid-stream. We always prepend to guarantee
-        that every IDR is self-contained.
-
-        Returns:
-            Modified data with SPS/PPS prepended to all IDR frames
-        """
-        if not self.cached_sps or not self.cached_pps:
-            return data
-
-        nal_units = self._find_nal_units(data)
-        if not nal_units:
-            return data
-
-        # Find all IDR frames
-        idr_positions = [
-            (start, size)
-            for start, nal_type, size, _ in nal_units
-            if nal_type == 5
-        ]
-
-        if not idr_positions:
-            return data
-
-        # Build modified data by prepending SPS/PPS before each IDR
-        result = bytearray()
-        last_pos = 0
-        sps_pps = self.cached_sps + self.cached_pps
-
-        for idr_start, idr_size in idr_positions:
-            # Add data before this IDR
-            result.extend(data[last_pos:idr_start])
-
-            # Check if SPS/PPS already exists right before this IDR
-            # (to avoid duplicating if scrcpy already sent them)
-            prepend_offset = max(0, idr_start - len(sps_pps))
-            if data[prepend_offset:idr_start] != sps_pps:
-                # Prepend SPS/PPS before this IDR
-                result.extend(sps_pps)
-                print(
-                    f"[ScrcpyStreamer] Prepended SPS/PPS before IDR at position {idr_start}"
-                )
-
-            # Update position to start of IDR
-            last_pos = idr_start
-
-        # Add remaining data (including all IDR frames and data after)
-        result.extend(data[last_pos:])
-
-        return bytes(result)
-
     def get_initialization_data(self) -> bytes | None:
         """Get cached SPS/PPS/IDR for initializing new connections.
 
@@ -563,6 +457,86 @@ class ScrcpyStreamer:
             )
             raise ConnectionError(f"Failed to read from socket: {e}") from e
 
+    async def read_nal_unit(self, auto_cache: bool = True) -> bytes:
+        """Read one complete NAL unit from socket.
+
+        This method ensures each returned chunk is a complete, self-contained NAL unit.
+        WebSocket messages will have clear semantic boundaries (one message = one NAL unit).
+
+        Args:
+            auto_cache: If True, automatically cache SPS/PPS/IDR from this NAL unit
+
+        Returns:
+            bytes: Complete NAL unit (including start code)
+
+        Raises:
+            ConnectionError: If socket is closed or error occurs
+        """
+        if not self.tcp_socket:
+            raise ConnectionError("Socket not connected")
+
+        while True:
+            # Look for start codes in buffer
+            buffer = bytes(self._nal_read_buffer)
+            start_positions = []
+
+            # Find all start codes (0x00 0x00 0x00 0x01 or 0x00 0x00 0x01)
+            i = 0
+            while i < len(buffer) - 3:
+                if buffer[i] == 0x00 and buffer[i + 1] == 0x00:
+                    if buffer[i + 2] == 0x00 and buffer[i + 3] == 0x01:
+                        start_positions.append(i)
+                        i += 4
+                    elif buffer[i + 2] == 0x01:
+                        start_positions.append(i)
+                        i += 3
+                    else:
+                        i += 1
+                else:
+                    i += 1
+
+            # If we have at least 2 start codes, we can extract the first NAL unit
+            if len(start_positions) >= 2:
+                # Extract first complete NAL unit (from first start code to second start code)
+                nal_unit = buffer[start_positions[0] : start_positions[1]]
+
+                # Remove extracted NAL unit from buffer
+                self._nal_read_buffer = bytearray(buffer[start_positions[1] :])
+
+                # Cache parameter sets if enabled
+                if auto_cache:
+                    self._cache_nal_units(nal_unit)
+
+                return nal_unit
+
+            # Need more data - read from socket
+            try:
+                loop = asyncio.get_event_loop()
+                chunk = await loop.run_in_executor(
+                    None, self.tcp_socket.recv, 512 * 1024
+                )
+
+                if not chunk:
+                    # Socket closed - return any remaining buffered data as final NAL unit
+                    if len(self._nal_read_buffer) > 0:
+                        final_nal = bytes(self._nal_read_buffer)
+                        self._nal_read_buffer.clear()
+                        if auto_cache:
+                            self._cache_nal_units(final_nal)
+                        return final_nal
+                    raise ConnectionError("Socket closed by remote")
+
+                # Append new data to buffer
+                self._nal_read_buffer.extend(chunk)
+
+            except ConnectionError:
+                raise
+            except Exception as e:
+                print(
+                    f"[ScrcpyStreamer] Unexpected error in read_nal_unit: {type(e).__name__}: {e}"
+                )
+                raise ConnectionError(f"Failed to read from socket: {e}") from e
+
     def stop(self) -> None:
         """Stop scrcpy server and cleanup resources."""
         # Close socket

autoglm_gui-0.4.7/AutoGLM_GUI/static/assets/about-DIdU3ZqP.js → autoglm_gui-0.4.9/AutoGLM_GUI/static/assets/about-BI6OV6gm.js

@@ -1 +1 @@
-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};
+import{j as o}from"./index-Dn3vR6uV.js";function t(){return o.jsx("div",{className:"p-2",children:o.jsx("h3",{children:"About"})})}export{t as component};