autoglm-gui 1.4.1__py3-none-any.whl → 1.5.0__py3-none-any.whl

AutoGLM_GUI/scrcpy_stream.py

@@ -5,6 +5,7 @@ import os
 import socket
 import subprocess
 import sys
+import time
 from dataclasses import dataclass
 from pathlib import Path
 from asyncio.subprocess import Process as AsyncProcess
@@ -23,6 +24,74 @@ from AutoGLM_GUI.scrcpy_protocol import (
 )
 
 
+async def is_port_available(port: int, host: str = "127.0.0.1") -> bool:
+    """Test if TCP port is available for binding.
+
+    Args:
+        port: TCP port number
+        host: Host address to test
+
+    Returns:
+        True if port can be bound (available), False otherwise
+    """
+    sock = None
+    try:
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        sock.setblocking(False)
+        sock.bind((host, port))
+        logger.debug(f"Port {port} is available for binding")
+        return True
+    except OSError as e:
+        # Handle cross-platform errno for "Address already in use"
+        # macOS: 48, Linux: 98, Windows: 10048
+        logger.debug(f"Port {port} is occupied: {e}")
+        return False
+    finally:
+        if sock:
+            sock.close()
+
+
+async def wait_for_port_release(
+    port: int,
+    timeout: float = 5.0,
+    poll_interval: float = 0.2,
+    host: str = "127.0.0.1",
+) -> bool:
+    """Wait for TCP port to become available with polling.
+
+    Args:
+        port: TCP port to wait for
+        timeout: Maximum wait time in seconds (default: 5.0)
+        poll_interval: Check interval in seconds (default: 0.2)
+        host: Host address
+
+    Returns:
+        True if port became available, False if timeout
+    """
+    start_time = time.time()
+    attempt = 0
+
+    while time.time() - start_time < timeout:
+        attempt += 1
+        if await is_port_available(port, host):
+            elapsed = time.time() - start_time
+            logger.info(
+                f"Port {port} became available after {elapsed:.2f}s ({attempt} checks)"
+            )
+            return True
+
+        # Log progress every second for debugging
+        if attempt % 5 == 0:  # Every 1 second (5 * 0.2s)
+            elapsed = time.time() - start_time
+            logger.debug(f"Still waiting for port {port}... ({elapsed:.1f}s elapsed)")
+
+        await asyncio.sleep(poll_interval)
+
+    logger.warning(f"Port {port} did not release within {timeout}s timeout")
+    return False
+
+
 @dataclass
 class ScrcpyServerOptions:
     max_size: int
@@ -159,29 +228,44 @@ class ScrcpyStreamer:
             raise RuntimeError(f"Failed to start scrcpy server: {e}") from e
 
     async def _cleanup_existing_server(self) -> None:
-        """Kill existing scrcpy server processes on device."""
+        """Kill existing scrcpy server processes and wait for port release."""
         cmd_base = ["adb"]
         if self.device_id:
             cmd_base.extend(["-s", self.device_id])
 
         # Method 1: Try pkill
+        logger.debug("Killing scrcpy processes via 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)
+        logger.debug("Killing scrcpy processes via PID...")
         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 3: Remove port forward if exists
+        # Method 3: Remove port forward
+        logger.debug(f"Removing ADB port forward on port {self.port}...")
         cmd_remove_forward = cmd_base + ["forward", "--remove", f"tcp:{self.port}"]
         await run_cmd_silently(cmd_remove_forward)
 
-        # Wait for resources to be released
-        logger.debug("Waiting for cleanup to complete...")
-        await asyncio.sleep(2)
+        # Wait for port to be truly available (instead of fixed sleep)
+        logger.info(f"Waiting for port {self.port} to be released...")
+        port_released = await wait_for_port_release(
+            self.port,
+            timeout=5.0,  # Max 5 seconds (vs old fixed 2s)
+            poll_interval=0.2,  # Check every 200ms
+        )
+
+        if not port_released:
+            logger.warning(
+                f"Port {self.port} still occupied after cleanup. "
+                "Will attempt to start anyway (may fail)."
+            )
+        else:
+            logger.info(f"Port {self.port} successfully released and ready")
 
     async def _push_server(self) -> None:
         """Push scrcpy-server to device."""
@@ -221,9 +305,9 @@ class ScrcpyStreamer:
         )
 
     async def _start_server(self) -> None:
-        """Start scrcpy server on device with retry on address conflict."""
+        """Start scrcpy server on device with intelligent retry."""
         max_retries = 3
-        retry_delay = 2
+        retry_delay = 1.0  # Reduced from 2s (cleanup handles waiting now)
 
         options = self._build_server_options()
 
@@ -275,43 +359,77 @@ class ScrcpyStreamer:
                         error_msg = stderr.decode() if stderr else stdout.decode()
 
             if error_msg is not None:
+                # Detailed error classification
                 if "Address already in use" in error_msg:
+                    logger.error(
+                        f"Port {self.port} conflict detected (attempt {attempt + 1}/{max_retries}). "
+                        f"Error: {error_msg[:200]}"
+                    )
                     if attempt < max_retries - 1:
                         logger.warning(
-                            f"Address in use, retrying in {retry_delay}s (attempt {attempt + 1}/{max_retries})..."
+                            f"Retrying with aggressive cleanup in {retry_delay}s..."
                         )
                         await self._cleanup_existing_server()
                         await asyncio.sleep(retry_delay)
                         continue
+                    # Specific error for port conflicts
                     raise RuntimeError(
-                        f"scrcpy server failed after {max_retries} attempts: {error_msg}"
+                        f"Port {self.port} persistently occupied after {max_retries} attempts. "
+                        "Please check if another scrcpy instance is running."
                     )
-                raise RuntimeError(f"scrcpy server exited immediately: {error_msg}")
+                else:
+                    # Non-port errors fail immediately (no retry)
+                    logger.error(f"Scrcpy server startup failed: {error_msg[:200]}")
+                    raise RuntimeError(f"Scrcpy server failed to start: {error_msg}")
 
+            logger.info("Scrcpy server started successfully")
             return
 
         raise RuntimeError("Failed to start scrcpy server after maximum retries")
 
     async def _connect_socket(self) -> None:
         """Connect to scrcpy TCP socket."""
-        self.tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        self.tcp_socket.settimeout(5)
+        # Retry connection with exponential backoff (max ~6 seconds total)
+        max_attempts = 10
+        retry_delay = 0.3
 
-        try:
-            self.tcp_socket.setsockopt(
-                socket.SOL_SOCKET, socket.SO_RCVBUF, 2 * 1024 * 1024
-            )
-            logger.debug("Set socket receive buffer to 2MB")
-        except OSError as e:
-            logger.warning(f"Failed to set socket buffer size: {e}")
+        for attempt in range(max_attempts):
+            # Create a fresh socket for each attempt to avoid "Invalid argument" error
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            sock.settimeout(5)
+
+            try:
+                sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 2 * 1024 * 1024)
+            except OSError as e:
+                logger.debug(f"Failed to set socket buffer size: {e}")
 
-        for _ in range(5):
             try:
-                self.tcp_socket.connect(("localhost", self.port))
-                self.tcp_socket.settimeout(None)
+                sock.connect(("localhost", self.port))
+                sock.settimeout(None)
+                self.tcp_socket = sock  # Only assign on success
+                logger.debug(f"Connected to scrcpy server on attempt {attempt + 1}")
                 return
-            except (ConnectionRefusedError, OSError):
-                await asyncio.sleep(0.5)
+            except (ConnectionRefusedError, OSError) as e:
+                # Close the failed socket
+                try:
+                    sock.close()
+                except Exception:
+                    pass
+
+                if attempt < max_attempts - 1:
+                    logger.debug(
+                        f"Connection attempt {attempt + 1}/{max_attempts} failed: {e}. "
+                        f"Retrying in {retry_delay}s..."
+                    )
+                    await asyncio.sleep(retry_delay)
+                    # Gradually increase delay for later attempts
+                    if attempt >= 3:
+                        retry_delay = 0.5
+                else:
+                    logger.error(
+                        f"Failed to connect after {max_attempts} attempts. "
+                        f"Last error: {e}"
+                    )
 
         raise ConnectionError("Failed to connect to scrcpy server")
 

AutoGLM_GUI/socketio_server.py

@@ -4,9 +4,8 @@ from __future__ import annotations
 
 import asyncio
 import time
-from typing import NotRequired
 
-from typing_extensions import TypedDict
+from typing_extensions import NotRequired, TypedDict
 
 import socketio
 
@@ -31,6 +30,9 @@ sio = socketio.AsyncServer(
 
 _socket_streamers: dict[str, ScrcpyStreamer] = {}
 _stream_tasks: dict[str, asyncio.Task] = {}
+_device_locks: dict[
+    str, asyncio.Lock
+] = {}  # Lock per device to prevent concurrent connections
 
 
 async def _stop_stream_for_sid(sid: str) -> None:
@@ -43,6 +45,46 @@ async def _stop_stream_for_sid(sid: str) -> None:
         streamer.stop()
 
 
+def _classify_error(exc: Exception) -> dict:
+    """Classify error and return user-friendly message."""
+    error_str = str(exc)
+
+    if "Address already in use" in error_str or (
+        "Port" in error_str and "occupied" in error_str
+    ):
+        return {
+            "message": "端口冲突，视频流端口仍被占用。通常会自动解决，如果持续出现请重启应用。",
+            "type": "port_conflict",
+            "technical_details": error_str,
+        }
+    elif "Device" in error_str and (
+        "not available" in error_str or "not found" in error_str
+    ):
+        return {
+            "message": "设备无响应，请检查 USB/WiFi 连接。",
+            "type": "device_offline",
+            "technical_details": error_str,
+        }
+    elif "timeout" in error_str.lower() or "timed out" in error_str.lower():
+        return {
+            "message": "连接超时，请检查设备连接后重试。",
+            "type": "timeout",
+            "technical_details": error_str,
+        }
+    elif "Failed to connect" in error_str:
+        return {
+            "message": "无法连接到 scrcpy 服务器，请检查设备连接。",
+            "type": "connection_failed",
+            "technical_details": error_str,
+        }
+    else:
+        return {
+            "message": error_str,
+            "type": "unknown",
+            "technical_details": error_str,
+        }
+
+
 def stop_streamers(device_id: str | None = None) -> None:
     """Stop active scrcpy streamers (all or by device)."""
     sids = list(_socket_streamers.keys())
@@ -103,35 +145,66 @@ async def disconnect(sid: str) -> None:
 async def connect_device(sid: str, data: dict | None) -> None:
     payload = data or {}
     device_id = payload.get("device_id") or payload.get("deviceId")
+    if not device_id:
+        await sio.emit(
+            "error",
+            {"message": "Device ID is required", "type": "invalid_request"},
+            to=sid,
+        )
+        return
+
     max_size = int(payload.get("maxSize") or 1280)
     bit_rate = int(payload.get("bitRate") or 4_000_000)
 
+    # Stop any existing stream for this sid
     await _stop_stream_for_sid(sid)
 
-    streamer = ScrcpyStreamer(
-        device_id=device_id,
-        max_size=max_size,
-        bit_rate=bit_rate,
-    )
-
-    try:
-        await streamer.start()
-        metadata = await streamer.read_video_metadata()
-        await sio.emit(
-            "video-metadata",
-            {
-                "deviceName": metadata.device_name,
-                "width": metadata.width,
-                "height": metadata.height,
-                "codec": metadata.codec,
-            },
-            to=sid,
+    # Get or create a lock for this device
+    if device_id not in _device_locks:
+        _device_locks[device_id] = asyncio.Lock()
+
+    device_lock = _device_locks[device_id]
+
+    # Acquire lock to prevent concurrent connections to the same device
+    async with device_lock:
+        logger.debug(f"Acquired device lock for {device_id}, sid: {sid}")
+
+        # Stop any existing streams for the same device (from other sids)
+        sids_to_stop = [
+            s
+            for s, streamer in _socket_streamers.items()
+            if s != sid and streamer.device_id == device_id
+        ]
+        for s in sids_to_stop:
+            logger.info(f"Stopping existing stream for device {device_id} from sid {s}")
+            await _stop_stream_for_sid(s)
+
+        streamer = ScrcpyStreamer(
+            device_id=device_id,
+            max_size=max_size,
+            bit_rate=bit_rate,
         )
-    except Exception as exc:
-        streamer.stop()
-        logger.exception("Failed to start scrcpy stream: %s", exc)
-        await sio.emit("error", {"message": str(exc)}, to=sid)
-        return
 
-    _socket_streamers[sid] = streamer
-    _stream_tasks[sid] = asyncio.create_task(_stream_packets(sid, streamer))
+        try:
+            await streamer.start()  # ScrcpyStreamer has built-in retry logic
+            metadata = await streamer.read_video_metadata()
+            await sio.emit(
+                "video-metadata",
+                {
+                    "deviceName": metadata.device_name,
+                    "width": metadata.width,
+                    "height": metadata.height,
+                    "codec": metadata.codec,
+                },
+                to=sid,
+            )
+
+            _socket_streamers[sid] = streamer
+            _stream_tasks[sid] = asyncio.create_task(_stream_packets(sid, streamer))
+
+        except Exception as exc:
+            streamer.stop()
+            logger.exception("Failed to start scrcpy stream: %s", exc)
+            # Use unified error classification
+            error_info = _classify_error(exc)
+            await sio.emit("error", error_info, to=sid)

AutoGLM_GUI/static/assets/{about-_XNhzQZX.js → about-BQm96DAl.js}

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

AutoGLM_GUI/static/assets/alert-dialog-B42XxGPR.js

@@ -0,0 +1 @@
+import{o as u,r as o,j as a,b as r,B as d}from"./index-CssG-3TH.js";import{P as g,b as x,c as f,d as m}from"./popover-DLsuV5Sx.js";import{D as p,d as h,e as w,f as j,g as D}from"./dialog-DZ78cEcj.js";const N=[["path",{d:"M20 6 9 17l-5-5",key:"1gmf2c"}]],b=u("check",N),c=o.createContext(void 0),P=({value:t="",onValueChange:e,children:s})=>{const[n,l]=o.useState(!1);return a.jsx(c.Provider,{value:{value:t,onValueChange:e||(()=>{}),open:n,setOpen:l},children:a.jsx(g,{open:n,onOpenChange:l,children:s})})},C=o.forwardRef(({className:t,children:e,...s},n)=>{if(!o.useContext(c))throw new Error("SelectTrigger must be used within Select");return a.jsx(x,{asChild:!0,children:a.jsxs("button",{ref:n,className:r("flex h-10 w-full items-center justify-between rounded-md border border-slate-200 bg-white px-3 py-2 text-sm ring-offset-white placeholder:text-slate-500 focus:outline-none focus:ring-2 focus:ring-slate-950 focus:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 dark:border-slate-800 dark:bg-slate-950 dark:ring-offset-slate-950 dark:placeholder:text-slate-400 dark:focus:ring-slate-300",t),...s,children:[e,a.jsx(f,{className:"h-4 w-4 opacity-50"})]})})});C.displayName="SelectTrigger";const V=({placeholder:t})=>{const e=o.useContext(c);if(!e)throw new Error("SelectValue must be used within Select");return a.jsx("span",{className:e.value?"":"text-slate-500",children:e.value||t})},I=({children:t,className:e})=>a.jsx(m,{className:r("w-[var(--radix-popover-trigger-width)] p-1",e),children:t}),O=({value:t,children:e,disabled:s,className:n})=>{const l=o.useContext(c);if(!l)throw new Error("SelectItem must be used within Select");const i=l.value===t;return a.jsxs("div",{role:"option","aria-selected":i,className:r("relative flex w-full cursor-pointer select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none hover:bg-slate-100 focus:bg-slate-100 dark:hover:bg-slate-800 dark:focus:bg-slate-800",s&&"pointer-events-none opacity-50",n),onClick:()=>{s||(l.onValueChange(t),l.setOpen(!1))},children:[a.jsx("span",{className:"absolute left-2 flex h-3.5 w-3.5 items-center justify-center",children:i&&a.jsx(b,{className:"h-4 w-4"})}),e]})},B=({open:t,onOpenChange:e,children:s})=>a.jsx(p,{open:t,onOpenChange:e,children:s}),v=o.forwardRef(({className:t,...e},s)=>a.jsx(h,{ref:s,className:r("sm:max-w-[425px]",t),...e}));v.displayName="AlertDialogContent";const F=({className:t,...e})=>a.jsx(w,{className:r(t),...e}),H=({className:t,...e})=>a.jsx(D,{className:r(t),...e}),A=o.forwardRef(({className:t,...e},s)=>a.jsx(j,{ref:s,className:r(t),...e}));A.displayName="AlertDialogTitle";const S=o.forwardRef(({className:t,...e},s)=>a.jsx("p",{ref:s,className:r("text-sm text-slate-500 dark:text-slate-400",t),...e}));S.displayName="AlertDialogDescription";const y=o.forwardRef(({className:t,...e},s)=>a.jsx(d,{ref:s,className:r(t),...e}));y.displayName="AlertDialogAction";const k=o.forwardRef(({className:t,...e},s)=>a.jsx(d,{ref:s,variant:"outline",className:r(t),...e}));k.displayName="AlertDialogCancel";export{B as A,P as S,C as a,V as b,I as c,O as d,v as e,F as f,A as g,S as h,H as i,k as j,y as k};