autoglm-gui 1.0.2__py3-none-any.whl → 1.2.0__py3-none-any.whl

AutoGLM_GUI/adb_plus/serial.py

@@ -1,12 +1,61 @@
 """Get device serial number using ADB."""
 
+import re
+from typing import Optional
+
 from AutoGLM_GUI.platform_utils import run_cmd_silently_sync
 
 
+def extract_serial_from_mdns(device_id: str) -> Optional[str]:
+    """
+    Extract hardware serial number from mDNS device ID.
+
+    mDNS service names follow the pattern: adb-{serial}[-{suffix}].{service_type}
+
+    Examples:
+        - "adb-243a09b7-cbCO6P._adb-tls-connect._tcp" → "243a09b7"
+        - "adb-243a09b7._adb._tcp" → "243a09b7"
+        - "adb-ABC123DEF.local" → "ABC123DEF"
+
+    Args:
+        device_id: The device ID (can be mDNS service name or regular device ID)
+
+    Returns:
+        Extracted serial number, or None if not a valid mDNS format
+    """
+    # Check if this is an mDNS device ID
+    mdns_indicators = [
+        "._adb-tls-connect._tcp",
+        "._adb-tls-pairing._tcp",
+        "._adb._tcp",
+        ".local",
+    ]
+
+    if not any(indicator in device_id for indicator in mdns_indicators):
+        return None
+
+    # Pattern: adb-{serial}[-{suffix}].{service_type}
+    # The serial is everything after "adb-" until the next hyphen or dot
+    # Match alphanumeric characters (not just hex)
+    pattern = r"adb-([0-9a-zA-Z]+)"
+    match = re.search(pattern, device_id)
+
+    if match:
+        serial = match.group(1)
+        # Validate serial format (alphanumeric, typically 6-16 chars)
+        if len(serial) >= 6 and serial.isalnum():
+            return serial
+
+    return None
+
+
 def get_device_serial(device_id: str, adb_path: str = "adb") -> str | None:
     """
     Get the real hardware serial number of a device.
 
+    For mDNS devices, attempts to extract serial from service name first.
+    Falls back to getprop for USB/WiFi devices or if extraction fails.
+
     This works for both USB and WiFi connected devices,
     returning the actual hardware serial number (ro.serialno).
 
@@ -17,6 +66,15 @@ def get_device_serial(device_id: str, adb_path: str = "adb") -> str | None:
     Returns:
         The device hardware serial number, or None if failed
     """
+    from AutoGLM_GUI.logger import logger
+
+    # Fast path: Try mDNS extraction first
+    mdns_serial = extract_serial_from_mdns(device_id)
+    if mdns_serial:
+        logger.debug(f"Extracted serial from mDNS name: {device_id} → {mdns_serial}")
+        return mdns_serial
+
+    # Fallback: Use getprop (original behavior)
     try:
         # Use getprop to get the actual hardware serial number
         # This works for both USB and WiFi connections
@@ -28,8 +86,9 @@ def get_device_serial(device_id: str, adb_path: str = "adb") -> str | None:
             serial = result.stdout.strip()
             # Filter out error messages and empty values
             if serial and not serial.startswith("error:") and serial != "unknown":
+                logger.debug(f"Got serial via getprop: {device_id} → {serial}")
                 return serial
-    except Exception:
-        pass
+    except Exception as e:
+        logger.debug(f"Failed to get serial via getprop for {device_id}: {e}")
 
     return None

AutoGLM_GUI/adb_plus/version.py

@@ -0,0 +1,81 @@
+"""ADB version detection and feature support checking."""
+
+import re
+from typing import Optional, Tuple
+
+from AutoGLM_GUI.logger import logger
+from AutoGLM_GUI.platform_utils import run_cmd_silently_sync
+
+
+def get_adb_version(adb_path: str = "adb") -> Optional[Tuple[int, int, int]]:
+    """
+    Get ADB version as (major, minor, patch) tuple.
+
+    Args:
+        adb_path: Path to adb executable
+
+    Returns:
+        Version tuple or None if failed
+
+    Example:
+        >>> get_adb_version()
+        (34, 0, 5)  # ADB version 34.0.5
+    """
+    try:
+        result = run_cmd_silently_sync([adb_path, "version"], timeout=3)
+
+        if result.returncode != 0:
+            return None
+
+        # Parse "Android Debug Bridge version 1.0.41"
+        # Or "Version 34.0.5-11580240"
+        match = re.search(r"version (\d+)\.(\d+)\.(\d+)", result.stdout, re.IGNORECASE)
+        if match:
+            return (int(match.group(1)), int(match.group(2)), int(match.group(3)))
+
+        # Legacy format: "Android Debug Bridge version 1.0.XX"
+        match = re.search(r"version 1\.0\.(\d+)", result.stdout)
+        if match:
+            return (1, 0, int(match.group(1)))
+
+        return None
+
+    except Exception as e:
+        logger.debug(f"Failed to get ADB version: {e}")
+        return None
+
+
+def supports_mdns_services(adb_path: str = "adb") -> bool:
+    """
+    Check if ADB supports 'mdns services' command.
+
+    This feature was added in ADB 30.0.0+ (Android 11 SDK Platform Tools).
+
+    Args:
+        adb_path: Path to adb executable
+
+    Returns:
+        True if supported, False otherwise
+    """
+    # Quick feature detection: try running the command
+    try:
+        result = run_cmd_silently_sync([adb_path, "mdns", "services"], timeout=5)
+
+        # If command succeeds or returns "List of discovered mdns services", it's supported
+        if result.returncode == 0 or "mdns services" in result.stdout.lower():
+            return True
+
+        # Check for "unknown command" error
+        stderr_lower = result.stderr.lower()
+        if "unknown" in stderr_lower or "not found" in stderr_lower:
+            logger.info(
+                "ADB does not support 'mdns services' command (requires ADB 30.0.0+)"
+            )
+            return False
+
+        # If we get here, assume not supported
+        return False
+
+    except Exception as e:
+        logger.debug(f"Failed to check mDNS support: {e}")
+        return False

AutoGLM_GUI/api/__init__.py

@@ -1,5 +1,6 @@
 """FastAPI application factory and route registration."""
 
+import asyncio
 import sys
 from importlib.resources import files
 from pathlib import Path
@@ -10,8 +11,9 @@ from fastapi.responses import FileResponse
 from fastapi.staticfiles import StaticFiles
 
 from AutoGLM_GUI.version import APP_VERSION
+from AutoGLM_GUI.adb_plus.qr_pair import qr_pairing_manager
 
-from . import agents, control, devices, media, version
+from . import agents, control, devices, media, version, workflows
 
 
 def _get_static_dir() -> Path | None:
@@ -55,6 +57,19 @@ def create_app() -> FastAPI:
     app.include_router(control.router)
     app.include_router(media.router)
     app.include_router(version.router)
+    app.include_router(workflows.router)
+
+    @app.on_event("startup")
+    async def startup_event():
+        """Initialize background tasks on server startup."""
+        # Start QR pairing session cleanup task
+        asyncio.create_task(qr_pairing_manager.cleanup_expired_sessions())
+
+        # Start device polling
+        from AutoGLM_GUI.device_manager import DeviceManager
+
+        device_manager = DeviceManager.get_instance()
+        device_manager.start_polling()
 
     static_dir = _get_static_dir()
     if static_dir is not None and static_dir.exists():