autoglm-gui 1.1.0__tar.gz → 1.2.0__tar.gz

{autoglm_gui-1.1.0 → autoglm_gui-1.2.0}/.gitignore

@@ -16,6 +16,7 @@ AutoGLM_GUI/static/
 # Frontend
 frontend/node_modules/
 frontend/dist/
+frontend/package-lock.json
 
 # Electron
 electron/node_modules/

{autoglm_gui-1.1.0 → autoglm_gui-1.2.0}/AutoGLM_GUI/adb_plus/__init__.py

@@ -4,11 +4,12 @@ from .keyboard_installer import ADBKeyboardInstaller
 from .screenshot import Screenshot, capture_screenshot
 from .touch import touch_down, touch_move, touch_up
 from .ip import get_wifi_ip
-from .serial import get_device_serial
+from .serial import get_device_serial, extract_serial_from_mdns
 from .device import check_device_available
 from .pair import pair_device
 from .mdns import discover_mdns_devices, MdnsDevice
 from .qr_pair import qr_pairing_manager
+from .version import get_adb_version, supports_mdns_services
 
 __all__ = [
     "ADBKeyboardInstaller",
@@ -19,9 +20,12 @@ __all__ = [
     "touch_up",
     "get_wifi_ip",
     "get_device_serial",
+    "extract_serial_from_mdns",
     "check_device_available",
     "pair_device",
     "discover_mdns_devices",
     "MdnsDevice",
     "qr_pairing_manager",
+    "get_adb_version",
+    "supports_mdns_services",
 ]

autoglm_gui-1.2.0/AutoGLM_GUI/adb_plus/serial.py

@@ -0,0 +1,94 @@
+"""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).
+
+    Args:
+        device_id: The device ID (can be USB serial or IP:port for WiFi)
+        adb_path: Path to adb executable (default: "adb")
+
+    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
+        result = run_cmd_silently_sync(
+            [adb_path, "-s", device_id, "shell", "getprop", "ro.serialno"],
+            timeout=3,
+        )
+        if result.returncode == 0:
+            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 as e:
+        logger.debug(f"Failed to get serial via getprop for {device_id}: {e}")
+
+    return None

autoglm_gui-1.2.0/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-1.1.0 → autoglm_gui-1.2.0}/AutoGLM_GUI/api/__init__.py

@@ -13,7 +13,7 @@ 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:
@@ -57,6 +57,7 @@ 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():
@@ -64,6 +65,12 @@ def create_app() -> FastAPI:
         # 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():
         assets_dir = static_dir / "assets"