Fix WD packed temperature, Tailscale IP discovery, and timeout error handling

Author: DAB-LABS

custom_components/smart_sniffer/config_flow.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import asyncio
+import ipaddress
 import logging
 from typing import Any
 
@@ -66,7 +68,7 @@ async def async_step_user(
 
             try:
                 await self._test_connection(host, port, token)
-            except aiohttp.ClientError:
+            except (aiohttp.ClientError, asyncio.TimeoutError, TimeoutError):
                 errors["base"] = "cannot_connect"
             except Exception:  # noqa: BLE001
                 _LOGGER.exception("Unexpected error during config flow")
@@ -84,11 +86,41 @@ async def async_step_user(
             errors=errors,
         )
 
+    @staticmethod
+    def _pick_best_ip(discovery_info: ZeroconfServiceInfo) -> str:
+        """Choose the best IP from discovery info.
+
+        Prefers RFC 1918 private addresses (192.168.x, 10.x, 172.16-31.x)
+        over VPN/tunnel IPs (Tailscale 100.x, WireGuard, etc.).  Falls back
+        to whatever is available.
+        """
+        # discovery_info may expose ip_address (single) and ip_addresses (list).
+        candidates: list[str] = []
+        if hasattr(discovery_info, "ip_addresses") and discovery_info.ip_addresses:
+            candidates = [str(a) for a in discovery_info.ip_addresses]
+        elif discovery_info.ip_address:
+            candidates = [str(discovery_info.ip_address)]
+
+        if not candidates:
+            return str(discovery_info.ip_address)
+
+        # Prefer private (RFC 1918) addresses over anything else.
+        for ip_str in candidates:
+            try:
+                addr = ipaddress.ip_address(ip_str)
+                if addr.is_private and not ip_str.startswith("100."):
+                    return ip_str
+            except ValueError:
+                continue
+
+        # No private IP found — return the first candidate.
+        return candidates[0]
+
     async def async_step_zeroconf(
         self, discovery_info: ZeroconfServiceInfo
     ) -> ConfigFlowResult:
         """Handle discovery via mDNS/Zeroconf."""
-        host = str(discovery_info.ip_address)
+        host = self._pick_best_ip(discovery_info)
         port = discovery_info.port
         properties = discovery_info.properties
 
@@ -126,7 +158,7 @@ async def async_step_zeroconf_confirm(
                 await self._test_connection(
                     self._discovery_host, self._discovery_port, token
                 )
-            except aiohttp.ClientError:
+            except (aiohttp.ClientError, asyncio.TimeoutError, TimeoutError):
                 errors["base"] = "cannot_connect"
             except Exception:  # noqa: BLE001
                 _LOGGER.exception("Unexpected error during zeroconf confirm")
@@ -202,7 +234,7 @@ async def async_step_init(
                     url, headers=headers, timeout=aiohttp.ClientTimeout(total=10)
                 ) as resp:
                     resp.raise_for_status()
-            except aiohttp.ClientError:
+            except (aiohttp.ClientError, asyncio.TimeoutError, TimeoutError):
                 errors["base"] = "cannot_connect"
             except Exception:  # noqa: BLE001
                 _LOGGER.exception("Unexpected error in options flow")

custom_components/smart_sniffer/sensor.py

@@ -297,7 +297,22 @@ def _extract_attribute(drive_data: dict[str, Any], key: str) -> Any | None:
         if attr.get("name") in names:
             raw = attr.get("raw", {})
             if isinstance(raw, dict):
-                return raw.get("value")
+                raw_value = raw.get("value")
+                # WD/HGST drives pack min/max/current into a single 48-bit
+                # raw value for Temperature_Celsius (e.g., 214749675563
+                # instead of 43).  The actual temp is in the low 16 bits.
+                # Parse raw.string first (e.g., "43 (Min/Max 20/50)"),
+                # fall back to masking if needed.
+                if key == "temperature" and isinstance(raw_value, int) and raw_value > 300:
+                    raw_string = raw.get("string", "")
+                    if raw_string:
+                        import re
+                        m = re.match(r"(\d+)", str(raw_string))
+                        if m:
+                            return int(m.group(1))
+                    # Fallback: low 16 bits hold current temp.
+                    return raw_value & 0xFFFF
+                return raw_value
             return raw
 
     return None