tescmd 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

tescmd/crypto/schnorr.py

@@ -0,0 +1,191 @@
+"""Schnorr signatures over NIST P-256 for Tesla Fleet Telemetry JWS.
+
+Implements the ``Tesla.SS256`` signing algorithm used by the Vehicle
+Command HTTP Proxy to sign fleet telemetry configurations.  This lets
+tescmd call the ``fleet_telemetry_config_jws`` endpoint directly,
+without requiring the Go-based ``tesla-http-proxy`` binary.
+
+Algorithm reference: github.com/teslamotors/vehicle-command
+    internal/schnorr/sign.go   — Sign()
+    internal/schnorr/schnorr.go — challenge(), Verify()
+    internal/authentication/jwt.go — SignMessage()
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+import json
+import struct
+from typing import Any
+
+from cryptography.hazmat.primitives.asymmetric import ec
+from cryptography.hazmat.primitives.serialization import Encoding, PublicFormat
+
+# ---------------------------------------------------------------------------
+# P-256 curve constants
+# ---------------------------------------------------------------------------
+
+P256_ORDER = 0xFFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551
+
+_P256_GX = 0x6B17D1F2E12C4247F8BCE6E563A440F277037D812DEB33A0F4A13945D898C296
+_P256_GY = 0x4FE342E2FE1A7F9B8EE7EB4A7C0F9E162BCE33576B315ECECBB6406837BF51F5
+
+# Generator point G in uncompressed X9.62 form (04 || X || Y).
+P256_GENERATOR_BYTES = b"\x04" + _P256_GX.to_bytes(32, "big") + _P256_GY.to_bytes(32, "big")
+
+_SCALAR_LEN = 32
+
+
+# ---------------------------------------------------------------------------
+# Low-level Schnorr primitives
+# ---------------------------------------------------------------------------
+
+
+def _deterministic_nonce(scalar: bytes, message_hash: bytes) -> bytes:
+    """RFC 6979 deterministic nonce generation for P-256 / SHA-256.
+
+    Mirrors ``DeterministicNonce`` in the Go SDK's ``internal/schnorr/sign.go``.
+    """
+    # Reduce message hash mod n
+    h1_int = int.from_bytes(message_hash, "big") % P256_ORDER
+    h1 = h1_int.to_bytes(32, "big")
+
+    # HMAC-DRBG initialisation (RFC 6979 S3.2 steps a-d)
+    k_mac = b"\x00" * 32
+    v = b"\x01" * 32
+
+    # Step d
+    k_mac = hmac.new(k_mac, v + b"\x00" + scalar + h1, hashlib.sha256).digest()
+    # Step e
+    v = hmac.new(k_mac, v, hashlib.sha256).digest()
+    # Step f
+    k_mac = hmac.new(k_mac, v + b"\x01" + scalar + h1, hashlib.sha256).digest()
+    # Step g
+    v = hmac.new(k_mac, v, hashlib.sha256).digest()
+
+    # Step h — generate candidates
+    while True:
+        v = hmac.new(k_mac, v, hashlib.sha256).digest()
+        nonce_int = int.from_bytes(v, "big")
+        if 0 < nonce_int < P256_ORDER:
+            return v
+
+        # Retry per spec
+        k_mac = hmac.new(k_mac, v + b"\x00", hashlib.sha256).digest()
+        v = hmac.new(k_mac, v, hashlib.sha256).digest()
+
+
+def _write_length_value(h: Any, data: bytes) -> None:
+    """Write a 4-byte big-endian length prefix then the data into *h*."""
+    h.update(struct.pack(">I", len(data)))
+    h.update(data)
+
+
+def _challenge(
+    public_nonce_uncompressed: bytes,
+    sender_public_uncompressed: bytes,
+    message: bytes,
+) -> bytes:
+    """Compute the Schnorr challenge hash.
+
+    ``SHA-256(len(G) || G || len(R) || R || len(P) || P || len(m) || m)``
+
+    Mirrors ``challenge()`` in ``internal/schnorr/schnorr.go``.
+    """
+    h = hashlib.sha256()
+    _write_length_value(h, P256_GENERATOR_BYTES)
+    _write_length_value(h, public_nonce_uncompressed)
+    _write_length_value(h, sender_public_uncompressed)
+    _write_length_value(h, message)
+    return h.digest()
+
+
+def schnorr_sign(
+    private_key: ec.EllipticCurvePrivateKey,
+    message: bytes,
+) -> bytes:
+    """Produce a 96-byte Tesla Schnorr/P-256 signature.
+
+    Returns ``nonce_X (32) || nonce_Y (32) || r (32)``.
+    """
+    # Private scalar bytes (big-endian, zero-padded to 32 bytes)
+    priv_numbers = private_key.private_numbers()
+    scalar = priv_numbers.private_value.to_bytes(_SCALAR_LEN, "big")
+
+    # Public key (uncompressed X9.62)
+    sender_public = private_key.public_key().public_bytes(
+        Encoding.X962, PublicFormat.UncompressedPoint
+    )
+
+    # 1. Deterministic nonce
+    digest = hashlib.sha256(message).digest()
+    nonce_bytes = _deterministic_nonce(scalar, digest)
+    nonce_int = int.from_bytes(nonce_bytes, "big")
+
+    # 2. Nonce public key  (k·G)
+    nonce_key = ec.derive_private_key(nonce_int, ec.SECP256R1())
+    nonce_public = nonce_key.public_key().public_bytes(
+        Encoding.X962, PublicFormat.UncompressedPoint
+    )  # 65 bytes: 04 || X || Y
+
+    # 3. Challenge  c = H(G, R, P, m)
+    c_bytes = _challenge(nonce_public, sender_public, message)
+    c_int = int.from_bytes(c_bytes, "big")
+
+    # 4. Response  r = k - x*c  (mod n)
+    x_int = priv_numbers.private_value
+    r_int = (nonce_int - x_int * c_int) % P256_ORDER
+
+    # 5. Signature = nonce_X || nonce_Y || r  (strip 0x04 prefix)
+    sig = nonce_public[1:] + r_int.to_bytes(_SCALAR_LEN, "big")
+    assert len(sig) == 3 * _SCALAR_LEN
+    return sig
+
+
+# ---------------------------------------------------------------------------
+# JWS token construction  (Tesla.SS256)
+# ---------------------------------------------------------------------------
+
+_JWS_HEADER = {"alg": "Tesla.SS256", "typ": "JWT"}
+
+
+def _b64url(data: bytes) -> str:
+    """Base64url-encode without padding (per RFC 7515)."""
+    return base64.urlsafe_b64encode(data).rstrip(b"=").decode("ascii")
+
+
+def sign_fleet_telemetry_config(
+    private_key: ec.EllipticCurvePrivateKey,
+    config: dict[str, Any],
+) -> str:
+    """Create a JWS token for a fleet telemetry config payload.
+
+    The *config* dict (hostname, ca, fields, alert_types) is signed with the
+    Tesla.SS256 algorithm.  ``iss`` and ``aud`` claims are set automatically.
+
+    Returns the compact JWS string for the ``fleet_telemetry_config_jws``
+    endpoint's ``token`` field.
+    """
+    # Build claims — shallow copy so we don't mutate the caller's dict
+    claims: dict[str, Any] = dict(config)
+
+    # iss = base64(uncompressed public key bytes)
+    pub_bytes = private_key.public_key().public_bytes(
+        Encoding.X962, PublicFormat.UncompressedPoint
+    )
+    claims["iss"] = base64.standard_b64encode(pub_bytes).decode("ascii")
+    claims["aud"] = "com.tesla.fleet.TelemetryClient"
+
+    # Serialise header & payload
+    header_b64 = _b64url(json.dumps(_JWS_HEADER, separators=(",", ":")).encode())
+    payload_b64 = _b64url(json.dumps(claims, separators=(",", ":")).encode())
+
+    signing_input = f"{header_b64}.{payload_b64}".encode("ascii")
+
+    # Sign
+    sig = schnorr_sign(private_key, signing_input)
+    sig_b64 = _b64url(sig)
+
+    return f"{header_b64}.{payload_b64}.{sig_b64}"

tescmd/deploy/tailscale_serve.py

@@ -0,0 +1,154 @@
+"""Tailscale Funnel deployment helpers for Tesla Fleet API public keys.
+
+Serves the public key at the Tesla-required ``.well-known`` path via
+Tailscale's ``serve`` + ``funnel`` commands.  All Tailscale interaction
+goes through :class:`~tescmd.telemetry.tailscale.TailscaleManager`.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from pathlib import Path
+
+import httpx
+
+from tescmd.api.errors import TailscaleError
+from tescmd.telemetry.tailscale import TailscaleManager
+
+logger = logging.getLogger(__name__)
+
+WELL_KNOWN_PATH = ".well-known/appspecific/com.tesla.3p.public-key.pem"
+DEFAULT_SERVE_DIR = Path("~/.config/tescmd/serve")
+
+# Polling for deployment validation
+DEFAULT_DEPLOY_TIMEOUT = 60  # seconds (faster than GitHub Pages)
+POLL_INTERVAL = 3  # seconds
+
+
+# ---------------------------------------------------------------------------
+# Key file management
+# ---------------------------------------------------------------------------
+
+
+async def deploy_public_key_tailscale(
+    public_key_pem: str,
+    serve_dir: Path | None = None,
+) -> Path:
+    """Write the PEM key into the serve directory structure.
+
+    Creates ``<serve_dir>/.well-known/appspecific/com.tesla.3p.public-key.pem``.
+
+    Returns the path to the written key file.
+    """
+    base = (serve_dir or DEFAULT_SERVE_DIR).expanduser()
+    key_path = base / WELL_KNOWN_PATH
+    key_path.parent.mkdir(parents=True, exist_ok=True)
+    key_path.write_text(public_key_pem)
+    logger.info("Public key written to %s", key_path)
+    return key_path
+
+
+# ---------------------------------------------------------------------------
+# Serve / Funnel lifecycle
+# ---------------------------------------------------------------------------
+
+
+async def start_key_serving(serve_dir: Path | None = None) -> str:
+    """Start ``tailscale serve`` for ``.well-known`` and enable Funnel.
+
+    Returns the public hostname (e.g. ``machine.tailnet.ts.net``).
+
+    Raises:
+        TailscaleError: If Tailscale is not ready or Funnel cannot start.
+    """
+    base = (serve_dir or DEFAULT_SERVE_DIR).expanduser()
+    well_known_dir = base / ".well-known"
+    if not well_known_dir.exists():
+        raise TailscaleError(
+            f"Serve directory not found: {well_known_dir}. "
+            "Run deploy_public_key_tailscale() first."
+        )
+
+    ts = TailscaleManager()
+    await ts.check_available()
+    hostname = await ts.get_hostname()
+
+    # Serve the .well-known directory at /.well-known/
+    await ts.start_serve("/.well-known/", str(well_known_dir))
+
+    # Enable Funnel to make it publicly accessible
+    await ts.enable_funnel()
+
+    logger.info("Key serving started at https://%s/%s", hostname, WELL_KNOWN_PATH)
+    return hostname
+
+
+async def stop_key_serving() -> None:
+    """Remove the ``.well-known`` serve handler."""
+    ts = TailscaleManager()
+    await ts.stop_serve("/.well-known/")
+    logger.info("Key serving stopped")
+
+
+# ---------------------------------------------------------------------------
+# Readiness check
+# ---------------------------------------------------------------------------
+
+
+async def is_tailscale_serve_ready() -> bool:
+    """Quick check: CLI on PATH + daemon running + Funnel available.
+
+    Returns bool, never raises.
+    """
+    try:
+        ts = TailscaleManager()
+        await ts.check_available()
+        await ts.check_running()
+        return await ts.check_funnel_available()
+    except (TailscaleError, Exception):
+        return False
+
+
+# ---------------------------------------------------------------------------
+# URL helpers and validation
+# ---------------------------------------------------------------------------
+
+
+def get_key_url(hostname: str) -> str:
+    """Return full URL to the public key."""
+    return f"https://{hostname}/{WELL_KNOWN_PATH}"
+
+
+async def validate_tailscale_key_url(hostname: str) -> bool:
+    """HTTP GET to verify key is accessible.
+
+    Returns True if the key is reachable and contains PEM content.
+    """
+    url = get_key_url(hostname)
+    try:
+        async with httpx.AsyncClient() as client:
+            resp = await client.get(url, follow_redirects=True, timeout=10)
+            return resp.status_code == 200 and "BEGIN PUBLIC KEY" in resp.text
+    except httpx.HTTPError:
+        return False
+
+
+async def wait_for_tailscale_deployment(
+    hostname: str,
+    *,
+    timeout: int = DEFAULT_DEPLOY_TIMEOUT,
+) -> bool:
+    """Poll key URL until accessible or *timeout* elapses.
+
+    Returns True if the key became accessible, False on timeout.
+    """
+    deadline = time.monotonic() + timeout
+
+    while time.monotonic() < deadline:
+        if await validate_tailscale_key_url(hostname):
+            return True
+        await asyncio.sleep(POLL_INTERVAL)
+
+    return False

tescmd/models/__init__.py

@@ -19,7 +19,6 @@ from tescmd.models.command import CommandResponse, CommandResult
 from tescmd.models.config import AppSettings, Profile
 from tescmd.models.energy import (
     CalendarHistory,
-    EnergySite,
     GridImportExportConfig,
     LiveStatus,
     SiteInfo,
@@ -61,7 +60,6 @@ __all__ = [
     "CommandResult",
     "DestChargerInfo",
     "DriveState",
-    "EnergySite",
     "FeatureConfig",
     "GridImportExportConfig",
     "GuiSettings",

tescmd/models/auth.py

@@ -17,6 +17,7 @@ VEHICLE_SCOPES: list[str] = [
     "vehicle_device_data",
     "vehicle_cmds",
     "vehicle_charging_cmds",
+    "vehicle_location",
 ]
 
 ENERGY_SCOPES: list[str] = [
@@ -99,6 +100,24 @@ def decode_jwt_scopes(token: str) -> list[str] | None:
     return None
 
 
+def decode_jwt_payload(token: str) -> dict[str, Any] | None:
+    """Decode the full JWT payload without verifying the signature.
+
+    Returns the payload dict, or ``None`` if the token isn't a valid JWT.
+    """
+    parts = token.split(".")
+    if len(parts) != 3:
+        return None
+    try:
+        payload_b64 = parts[1] + "=" * (-len(parts[1]) % 4)
+        payload_bytes = base64.urlsafe_b64decode(payload_b64)
+        payload: dict[str, Any] = json.loads(payload_bytes)
+    except (ValueError, json.JSONDecodeError):
+        logger.debug("Failed to decode JWT payload")
+        return None
+    return payload
+
+
 class AuthConfig(BaseModel):
     """Configuration needed to start an OAuth flow."""
 

tescmd/models/config.py

@@ -43,6 +43,7 @@ class AppSettings(BaseSettings):
     profile: str = "default"
     setup_tier: str | None = None
     github_repo: str | None = None
+    hosting_method: str | None = None  # "github" | "tailscale" | None (manual)
     access_token: str | None = None
     refresh_token: str | None = None
 

tescmd/models/energy.py

@@ -9,15 +9,6 @@ from pydantic import BaseModel, ConfigDict
 _EXTRA_ALLOW = ConfigDict(extra="allow")
 
 
-class EnergySite(BaseModel):
-    model_config = _EXTRA_ALLOW
-
-    energy_site_id: int
-    resource_type: str | None = None
-    site_name: str | None = None
-    gateway_id: str | None = None
-
-
 class LiveStatus(BaseModel):
     model_config = _EXTRA_ALLOW
 

tescmd/protocol/session.py

@@ -72,7 +72,12 @@ class Session:
         return time.monotonic() - self.created_at > self.ttl
 
     def next_counter(self) -> int:
-        """Return and increment the anti-replay counter."""
+        """Return and increment the anti-replay counter.
+
+        This is safe because all callers run on the same asyncio event
+        loop and ``next_counter`` is synchronous — no ``await`` between
+        the read and the increment means no interleaving is possible.
+        """
         self.counter += 1
         return self.counter
 
@@ -105,8 +110,10 @@ class SessionManager:
         """Return a valid session, performing a handshake if needed."""
         key = (vin, domain)
         session = self._sessions.get(key)
-        if session is not None and not session.is_expired:
-            return session
+        if session is not None:
+            if not session.is_expired:
+                return session
+            del self._sessions[key]
 
         session = await self._handshake(vin, domain)
         self._sessions[key] = session

tescmd/telemetry/__init__.py

@@ -0,0 +1,19 @@
+"""Fleet Telemetry streaming — WebSocket server, decoder, and dashboard."""
+
+from __future__ import annotations
+
+from tescmd.telemetry.decoder import TelemetryDatum, TelemetryDecoder, TelemetryFrame
+from tescmd.telemetry.fields import FIELD_NAMES, PRESETS, resolve_fields
+from tescmd.telemetry.server import TelemetryServer
+from tescmd.telemetry.tailscale import TailscaleManager
+
+__all__ = [
+    "FIELD_NAMES",
+    "PRESETS",
+    "TailscaleManager",
+    "TelemetryDatum",
+    "TelemetryDecoder",
+    "TelemetryFrame",
+    "TelemetryServer",
+    "resolve_fields",
+]

tescmd/telemetry/dashboard.py

@@ -0,0 +1,227 @@
+"""Rich Live TUI dashboard for real-time telemetry display."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from typing import TYPE_CHECKING, Any
+
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+if TYPE_CHECKING:
+    from rich.console import Console, RenderableType
+    from rich.live import Live
+
+    from tescmd.output.rich_output import DisplayUnits
+    from tescmd.telemetry.decoder import TelemetryFrame
+
+
+class TelemetryDashboard:
+    """Rich Live TUI renderer for streaming telemetry data."""
+
+    def __init__(self, console: Console, units: DisplayUnits) -> None:
+        self._console = console
+        self._units = units
+        self._state: dict[str, Any] = {}
+        self._timestamps: dict[str, datetime] = {}
+        self._frame_count: int = 0
+        self._vin: str = ""
+        self._started_at: datetime = datetime.now(tz=UTC)
+        self._live: Live | None = None
+        self._connected: bool = False
+        self._tunnel_url: str = ""
+
+    def update(self, frame: TelemetryFrame) -> None:
+        """Ingest a telemetry frame and refresh the display."""
+        self._frame_count += 1
+        self._connected = True
+        if frame.vin:
+            self._vin = frame.vin
+
+        for datum in frame.data:
+            self._state[datum.field_name] = datum.value
+            self._timestamps[datum.field_name] = frame.created_at
+
+        # Trigger an immediate refresh so data appears without waiting for the
+        # next auto-refresh tick.  We do NOT call live.update(self.render())
+        # because that would replace the Live renderable with a static snapshot,
+        # breaking the uptime counter between frames.  The Live object already
+        # holds a reference to `self` (via __rich__), so refresh() re-renders
+        # the dashboard with the freshly updated state.
+        if self._live is not None:
+            self._live.refresh()
+
+    def set_live(self, live: Live) -> None:
+        """Attach a Rich Live instance for auto-refresh."""
+        self._live = live
+
+    def set_tunnel_url(self, url: str) -> None:
+        """Set the tunnel URL for display."""
+        self._tunnel_url = url
+
+    def __rich__(self) -> RenderableType:
+        """Allow Rich Live to call render() on every refresh tick."""
+        return self.render()
+
+    def render(self) -> RenderableType:
+        """Build the full dashboard renderable."""
+        from rich.console import Group
+
+        parts: list[RenderableType] = []
+
+        # Header panel
+        parts.append(self._render_header())
+
+        # Data table
+        if self._state:
+            parts.append(self._render_data_table())
+        else:
+            parts.append(
+                Panel(
+                    "[dim]Waiting for telemetry data...[/dim]",
+                    title="Telemetry Data",
+                    border_style="dim",
+                )
+            )
+
+        # Footer
+        parts.append(self._render_footer())
+
+        return Group(*parts)
+
+    def _render_header(self) -> Panel:
+        """Render the status header panel."""
+        now = datetime.now(tz=UTC)
+        uptime = now - self._started_at
+        hours, remainder = divmod(int(uptime.total_seconds()), 3600)
+        minutes, seconds = divmod(remainder, 60)
+
+        status_style = "green" if self._connected else "yellow"
+        status_text = "Connected" if self._connected else "Waiting"
+
+        header = Text()
+        header.append("VIN: ", style="bold")
+        header.append(self._vin or "(waiting)", style="cyan")
+        header.append("  |  Status: ", style="bold")
+        header.append(status_text, style=status_style)
+        header.append("  |  Frames: ", style="bold")
+        header.append(str(self._frame_count), style="cyan")
+        header.append("  |  Uptime: ", style="bold")
+        header.append(f"{hours:02d}:{minutes:02d}:{seconds:02d}", style="cyan")
+
+        return Panel(header, title="Fleet Telemetry Stream", border_style="blue")
+
+    def _render_data_table(self) -> Table:
+        """Render the telemetry data table."""
+        table = Table(title="Telemetry Data", expand=True)
+        table.add_column("Field", style="bold", no_wrap=True)
+        table.add_column("Value", style="cyan")
+        table.add_column("Last Update", style="dim", no_wrap=True)
+
+        for field_name in sorted(self._state.keys()):
+            value = self._state[field_name]
+            display_value = self._format_value(field_name, value)
+            ts = self._timestamps.get(field_name)
+            ts_str = ts.strftime("%H:%M:%S") if ts else ""
+            table.add_row(field_name, display_value, ts_str)
+
+        return table
+
+    def _render_footer(self) -> Text:
+        """Render the footer with stream URL and exit hint."""
+        footer = Text()
+        if self._tunnel_url:
+            footer.append("  Stream: ", style="dim")
+            footer.append(self._tunnel_url, style="dim cyan")
+            footer.append("  |  ", style="dim")
+        footer.append("Press q or Ctrl+C to stop", style="dim")
+        return footer
+
+    def _format_value(self, field_name: str, value: Any) -> str:
+        """Format a telemetry value with unit conversion where applicable."""
+        from tescmd.output.rich_output import DistanceUnit, PressureUnit, TempUnit
+
+        if value is None:
+            return "—"
+
+        if isinstance(value, dict):
+            # Location
+            lat = value.get("latitude", 0.0)
+            lng = value.get("longitude", 0.0)
+            return f"{lat:.6f}, {lng:.6f}"
+
+        if isinstance(value, bool):
+            return "Yes" if value else "No"
+
+        # Temperature fields (API returns Celsius)
+        temp_fields = {
+            "InsideTemp",
+            "OutsideTemp",
+            "DriverTempSetting",
+            "PassengerTempSetting",
+            "ModuleTempMax",
+            "ModuleTempMin",
+        }
+        if field_name in temp_fields and isinstance(value, (int, float)):
+            if self._units.temp == TempUnit.F:
+                return f"{value * 9 / 5 + 32:.1f}°F"
+            return f"{value:.1f}°C"
+
+        # Distance fields (API returns miles)
+        distance_fields = {
+            "Odometer",
+            "EstBatteryRange",
+            "IdealBatteryRange",
+            "RatedBatteryRange",
+            "MilesToArrival",
+        }
+        if field_name in distance_fields and isinstance(value, (int, float)):
+            if self._units.distance == DistanceUnit.KM:
+                return f"{value * 1.60934:.1f} km"
+            return f"{value:.1f} mi"
+
+        # Speed fields (API returns mph)
+        speed_fields = {"VehicleSpeed", "CruiseSetSpeed", "MaxSpeedLimit"}
+        if field_name in speed_fields and isinstance(value, (int, float)):
+            if self._units.distance == DistanceUnit.KM:
+                return f"{value * 1.60934:.0f} km/h"
+            return f"{value:.0f} mph"
+
+        # Pressure fields (API returns bar)
+        pressure_fields = {
+            "TpmsPressureFl",
+            "TpmsPressureFr",
+            "TpmsPressureRl",
+            "TpmsPressureRr",
+        }
+        if field_name in pressure_fields and isinstance(value, (int, float)):
+            if self._units.pressure == PressureUnit.PSI:
+                return f"{value * 14.5038:.1f} psi"
+            return f"{value:.2f} bar"
+
+        # Percentage fields
+        pct_fields = {"Soc", "BatteryLevel", "ChargeLimitSoc"}
+        if field_name in pct_fields and isinstance(value, (int, float)):
+            return f"{value}%"
+
+        # Voltage / current
+        if "Voltage" in field_name and isinstance(value, (int, float)):
+            return f"{value:.1f} V"
+        if ("Current" in field_name or "Amps" in field_name) and isinstance(value, (int, float)):
+            return f"{value:.1f} A"
+
+        # Power
+        if "Power" in field_name and isinstance(value, (int, float)):
+            return f"{value:.2f} kW"
+
+        # Time-to-full
+        if field_name == "TimeToFullCharge" and isinstance(value, (int, float)):
+            hours = int(value)
+            mins = int((value - hours) * 60)
+            return f"{hours}h {mins}m" if hours else f"{mins}m"
+
+        if isinstance(value, float):
+            return f"{value:.2f}"
+
+        return str(value)