tesla-cli 4.8.1__tar.gz → 4.9.0__tar.gz

{tesla_cli-4.8.1 → tesla_cli-4.9.0}/CHANGELOG.md

@@ -5,6 +5,44 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [4.9.0] - 2026-04-06
+
+### Dashboard
+- **Dedicated Order page** with 15-step financing/delivery tracker
+- **Energy page** — Powerwall controls, city tariff comparison, cost calculator
+- **Automations page** — CRUD rules, quick setup, test/toggle/delete
+- **Notification history** timeline in Settings
+- **Offline mode** — cached vehicle data when server is down
+- **Mobile responsive** — CSS breakpoints for phones/tablets
+- **Scene cards** on dashboard (Morning/Goodnight/Trip)
+- **Code-split routes** — lazy-loaded pages for faster initial load
+
+### API (30+ new endpoints)
+- Energy management: sites, status, backup, mode, storm
+- Automations: CRUD, enable/disable, test, status
+- Charge scheduling + analytics: sessions, cost, forecast
+- Service: history, appointments, reminders
+- Scenes: list + execute
+- ABRP, BLE, MQTT, Dashcam endpoints
+- Energy tariffs: by city/estrato + vehicle location
+- 429 rate-limit retry with Retry-After
+
+### CLI
+- BLE key management (enroll, list, remove, state reads)
+- Safety Score + Service scheduling (first-mover)
+- EV vs gas savings calculator
+- Location-based charge/precondition schedules
+- Country-aware sources (9 countries, 35+ sources)
+- Dashcam processing (list/process/export)
+- Webhook automations (IFTTT/HomeKit/Google Home)
+- Energy tariffs command
+
+### Quality
+- 17 UI bugs fixed (critical crashes, color errors, missing guards)
+- Error boundary + React.Suspense on all lazy routes
+- Flaky test fixed permanently
+- 1682 tests passing
+
 ## [4.8.0] - 2026-04-05
 
 ### New Features

{tesla_cli-4.8.1 → tesla_cli-4.9.0}/CLAUDE.md

@@ -4,7 +4,7 @@
 
 Full-stack Tesla management platform: CLI (Typer) + REST API (FastAPI) + Web Dashboard (React/Ionic). Tracks orders, controls vehicles, aggregates data from 15+ sources, integrates with TeslaMate/MQTT/HA/ABRP.
 
-**Version**: v4.8.0 | **Python**: 3.12+ | **Package manager**: uv | **Tests**: 1679
+**Version**: v4.9.0 | **Python**: 3.12+ | **Package manager**: uv | **Tests**: 1682
 
 ## Architecture (quick reference)
 

{tesla_cli-4.8.1 → tesla_cli-4.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tesla-cli
-Version: 4.8.1
+Version: 4.9.0
 Summary: CLI tool for Tesla order tracking and vehicle control
 Project-URL: Homepage, https://github.com/dacrypt/tesla
 Project-URL: Repository, https://github.com/dacrypt/tesla
@@ -35,10 +35,6 @@ Requires-Dist: pytest>=8; extra == 'dev'
 Requires-Dist: ruff>=0.9; extra == 'dev'
 Provides-Extra: fleet
 Requires-Dist: tesla-fleet-api>=1.0; extra == 'fleet'
-Provides-Extra: ocr
-Requires-Dist: easyocr>=1.7; extra == 'ocr'
-Requires-Dist: paddleocr>=3.0; extra == 'ocr'
-Requires-Dist: paddlepaddle>=3.0; extra == 'ocr'
 Provides-Extra: pdf
 Requires-Dist: fpdf2>=2.7; extra == 'pdf'
 Provides-Extra: query

tesla_cli-4.9.0/cron-runt-check.sh

@@ -0,0 +1,39 @@
+#!/bin/bash
+set -euo pipefail
+cd /Users/david/dev/dacrypt/tesla
+
+if [ -x .venv/bin/python3 ]; then
+  PY=.venv/bin/python3
+else
+  PY=python3
+fi
+
+rm -f history/last-changes.json history/pending-alert.txt
+
+"$PY" refresh-mission-control.py
+CHANGE_OUTPUT=$("$PY" change-detector.py 2>&1 || true)
+echo "$CHANGE_OUTPUT"
+bash build-activity-log.sh
+
+if echo "$CHANGE_OUTPUT" | grep -q "✅ No changes detected"; then
+  echo "NO_CHANGES"
+  exit 0
+fi
+
+if [ -f history/last-changes.json ]; then
+  python3 - <<'PY'
+import json
+from pathlib import Path
+p = Path('history/last-changes.json')
+if not p.exists():
+    print('NO_CHANGES')
+    raise SystemExit(0)
+obj = json.loads(p.read_text())
+if obj.get('has_changes'):
+    print(obj.get('alert','').strip())
+else:
+    print('NO_CHANGES')
+PY
+else
+  echo "NO_CHANGES"
+fi

tesla_cli-4.9.0/plugins/claude-code/skills/energy/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: energy
+description: >
+  Tesla energy management — Powerwall status, Solar production, electricity
+  tariffs by city, backup reserve, operation mode, storm watch.
+argument-hint: "[query: status|tariffs|backup|mode|storm|savings]"
+allowed-tools: Bash(tesla *)
+level: 2
+---
+
+# Tesla Energy Management
+
+Monitor and control Powerwall, solar production, and electricity tariffs.
+
+## Powerwall Status
+
+```bash
+tesla energy status              # Powerwall charge %, solar W, grid W, home W
+tesla energy status --oneline    # compact: 🔋 82% | ☀️ 3.2kW solar | 🏠 1.1kW home
+```
+
+## Tariffs by City
+
+```bash
+tesla data energia --ciudad bogota --estrato 4   # tariff for Bogotá estrato 4
+tesla data energia --ciudad medellin --estrato 3  # Medellín estrato 3
+tesla data energia                                # use vehicle location automatically
+```
+
+Shows COP/kWh rate, tier breakdown, and estimated monthly cost.
+
+## Backup Reserve
+
+```bash
+tesla energy backup              # show current backup reserve %
+tesla energy backup 30           # set backup reserve to 30%
+```
+
+## Operation Mode
+
+```bash
+tesla energy mode                        # show current mode
+tesla energy mode self_consumption       # maximize solar self-consumption
+tesla energy mode autonomous             # Time-Based Control (TOU)
+tesla energy mode backup                 # full backup mode
+```
+
+## Storm Watch
+
+```bash
+tesla energy storm --on          # enable Storm Watch (charge to 100%)
+tesla energy storm --off         # disable Storm Watch
+```
+
+## Savings Calculator
+
+```bash
+tesla charge savings             # EV vs gas savings summary
+tesla charge savings --months 6  # last 6 months comparison
+```
+
+## Response Guidelines
+
+- If the CLI is not configured, **stop and tell the user to run `/tesla:setup`** — never auto-configure
+- Start with Powerwall % and current solar/grid/home power flows
+- For tariff queries: show rate in COP/kWh and compare to grid cost
+- For backup/mode changes: confirm the new setting after applying
+- For `$ARGUMENTS`:
+  - "status" / no args → `tesla energy status`
+  - "tariffs" / "precio" / "estrato" → `tesla data energia`
+  - "backup" → `tesla energy backup`
+  - "mode" / "modo" → `tesla energy mode`
+  - "storm" → `tesla energy storm`
+  - "savings" / "ahorro" → `tesla charge savings`

{tesla_cli-4.8.1 → tesla_cli-4.9.0}/plugins/claude-code/skills/order/SKILL.md

@@ -25,7 +25,7 @@ tesla order delivery             # delivery appointment (date, time, location)
 
 ```bash
 tesla order eta                  # delivery ETA (best/typical/worst estimates)
-tesla order gates                # 13-gate delivery journey tracker
+tesla order gates                # 15-step financing/delivery journey tracker (gates 1–15)
 tesla order estimate             # community-based delivery date estimation
 tesla order stores               # nearby Tesla stores/Service Centers
 tesla order stores --near 4.6,-74.1  # stores near coordinates
@@ -73,7 +73,7 @@ tesla order documents --download # download all to ~/.tesla-cli/documents/
 
 - If the CLI is not configured, **stop and tell the user to run `/tesla:setup`** — never auto-configure
 - Start with the **current order status** and **delivery date** if available
-- Show the gate progress (which of 13 gates have been passed)
+- Show the gate progress (which of the 15 financing/delivery steps have been passed)
 - If the car hasn't been delivered yet, include ETA estimates
 - If delivery is upcoming, suggest the checklist
 - For `$ARGUMENTS`:

{tesla_cli-4.8.1 → tesla_cli-4.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tesla-cli"
-version = "4.8.1"
+version = "4.9.0"
 description = "CLI tool for Tesla order tracking and vehicle control"
 readme = "README.md"
 license = { text = "MIT" }
@@ -36,7 +36,6 @@ teslaMate = ["psycopg2-binary>=2.9"]
 pdf = ["fpdf2>=2.7"]
 serve = ["fastapi>=0.110", "uvicorn[standard]>=0.29"]
 query = ["openquery"]
-ocr = ["paddlepaddle>=3.0", "paddleocr>=3.0", "easyocr>=1.7"]
 dev = ["pytest>=8", "pytest-httpx>=0.35", "ruff>=0.9"]
 
 [project.scripts]

{tesla_cli-4.8.1 → tesla_cli-4.9.0}/src/tesla_cli/__init__.py

@@ -1,3 +1,3 @@
 """Tesla CLI - Order tracking and vehicle control."""
 
-__version__ = "4.0.0"
+__version__ = "4.8.1"

{tesla_cli-4.8.1 → tesla_cli-4.9.0}/src/tesla_cli/api/app.py

@@ -193,13 +193,19 @@ def _register_middleware(app: FastAPI) -> None:
 
 def _register_routes(app: FastAPI) -> None:
     """Include all API routers."""
+    from tesla_cli.api.routes.abrp import router as abrp_router
     from tesla_cli.api.routes.auth import router as auth_router
+    from tesla_cli.api.routes.automations import router as automations_router
+    from tesla_cli.api.routes.ble import router as ble_router
     from tesla_cli.api.routes.charge import router as charge_router
     from tesla_cli.api.routes.climate import router as climate_router
     from tesla_cli.api.routes.colombia import router as colombia_router
+    from tesla_cli.api.routes.dashcam import router as dashcam_router
     from tesla_cli.api.routes.dossier import router as dossier_router
+    from tesla_cli.api.routes.energy_prices import router as energy_prices_router
     from tesla_cli.api.routes.fleet import router as fleet_router
     from tesla_cli.api.routes.geofence import router as geofence_router
+    from tesla_cli.api.routes.mqtt import router as mqtt_router
     from tesla_cli.api.routes.notify import router as notify_router
     from tesla_cli.api.routes.order import router as order_router
     from tesla_cli.api.routes.security import router as security_router
@@ -210,6 +216,7 @@ def _register_routes(app: FastAPI) -> None:
     app.include_router(auth_router, prefix="/api/auth", tags=["Auth"])
     app.include_router(sources_router, prefix="/api/sources", tags=["Sources"])
     app.include_router(colombia_router, prefix="/api/co", tags=["Colombia"])
+    app.include_router(energy_prices_router, prefix="/api/energy", tags=["Energy"])
     app.include_router(vehicle_router, prefix="/api/vehicle", tags=["Vehicle"])
     app.include_router(charge_router, prefix="/api/charge", tags=["Charge"])
     app.include_router(climate_router, prefix="/api/climate", tags=["Climate"])
@@ -220,6 +227,76 @@ def _register_routes(app: FastAPI) -> None:
     app.include_router(geofence_router, prefix="/api/geofences", tags=["Geofences"])
     app.include_router(teslaMate_router, prefix="/api/teslaMate", tags=["TeslaMate"])
     app.include_router(fleet_router, prefix="/api/fleet", tags=["Fleet"])
+    app.include_router(automations_router, prefix="/api/automations", tags=["Automations"])
+    app.include_router(abrp_router, prefix="/api/abrp", tags=["ABRP"])
+    app.include_router(ble_router, prefix="/api/ble", tags=["BLE"])
+    app.include_router(mqtt_router, prefix="/api/mqtt", tags=["MQTT"])
+    app.include_router(dashcam_router, prefix="/api/dashcam", tags=["Dashcam"])
+
+
+def _build_health_deep(result: dict) -> dict:
+    """Extend health result with deep diagnostics."""
+    from tesla_cli.core.auth import tokens
+
+    cfg = load_config()
+    result["backend"] = cfg.general.backend
+    result["vin_configured"] = bool(cfg.general.default_vin)
+    result["has_auth_token"] = tokens.has_token(tokens.ORDER_REFRESH_TOKEN)
+    result["telemetry_enabled"] = cfg.telemetry.enabled
+    result["teslamate_managed"] = cfg.teslaMate.managed
+    return result
+
+
+def _build_vehicles_list(cfg) -> list:
+    """Build the vehicles list from config (default VIN + aliases)."""
+    vehicles = []
+    default = cfg.general.default_vin
+    if default:
+        vehicles.append({"vin": default, "alias": "default", "is_default": True})
+    for alias, vin in cfg.vehicles.aliases.items():
+        if vin != default:
+            vehicles.append({"vin": vin, "alias": alias, "is_default": False})
+    return vehicles
+
+
+def _build_config_response(cfg) -> dict:
+    """Serialize public config fields for /api/config."""
+    return {
+        "backend": cfg.general.backend,
+        "default_vin": cfg.general.default_vin,
+        "cost_per_kwh": cfg.general.cost_per_kwh,
+        "teslaMate_url": bool(cfg.teslaMate.database_url),
+        "ha_url": cfg.home_assistant.url,
+        "abrp_configured": bool(cfg.abrp.user_token),
+        "geofences": list(cfg.geofences.zones.keys()),
+        "notifications": cfg.notifications.enabled,
+        "vehicles": cfg.vehicles.aliases,
+        "auth_enabled": bool(cfg.server.api_key),
+    }
+
+
+def _build_provider_capabilities() -> dict:
+    """Build capability map from the provider registry."""
+    from tesla_cli.core.providers import get_registry
+    from tesla_cli.core.providers.base import Capability
+
+    registry = get_registry()
+    out = {}
+    for cap in sorted(Capability.all()):
+        available = [p.name for p in registry.for_capability(cap)]
+        all_p = [p.name for p in registry.for_capability(cap, available_only=False)]
+        out[cap] = {"available": available, "all": all_p}
+    return out
+
+
+def _build_config_validation(cfg) -> dict:
+    """Run config checks and return a structured validation result."""
+    from tesla_cli.cli.commands.config_cmd import _run_config_checks
+
+    checks = _run_config_checks(cfg)
+    errors = sum(1 for c in checks if c["status"] == "error")
+    warnings = sum(1 for c in checks if c["status"] == "warn")
+    return {"valid": errors == 0, "errors": errors, "warnings": warnings, "checks": checks}
 
 
 def _register_system_endpoints(app: FastAPI) -> None:
@@ -235,14 +312,7 @@ def _register_system_endpoints(app: FastAPI) -> None:
         """
         result: dict = {"status": "ok", "version": __version__}
         if deep:
-            from tesla_cli.core.auth import tokens
-
-            cfg = load_config()
-            result["backend"] = cfg.general.backend
-            result["vin_configured"] = bool(cfg.general.default_vin)
-            result["has_auth_token"] = tokens.has_token(tokens.ORDER_REFRESH_TOKEN)
-            result["telemetry_enabled"] = cfg.telemetry.enabled
-            result["teslamate_managed"] = cfg.teslaMate.managed
+            _build_health_deep(result)
         return result
 
     @app.get("/api/status", tags=["System"])
@@ -258,33 +328,11 @@ def _register_system_endpoints(app: FastAPI) -> None:
     @app.get("/api/vehicles", tags=["System"])
     def api_vehicles() -> list:
         """List all configured vehicles (aliases + default VIN)."""
-        cfg = load_config()
-        vehicles = []
-        # Always include the default VIN first
-        default = cfg.general.default_vin
-        if default:
-            vehicles.append({"vin": default, "alias": "default", "is_default": True})
-        # Add any aliases that are different from the default
-        for alias, vin in cfg.vehicles.aliases.items():
-            if vin != default:
-                vehicles.append({"vin": vin, "alias": alias, "is_default": False})
-        return vehicles
+        return _build_vehicles_list(load_config())
 
     @app.get("/api/config", tags=["System"])
     def api_config() -> dict:
-        cfg = load_config()
-        return {
-            "backend": cfg.general.backend,
-            "default_vin": cfg.general.default_vin,
-            "cost_per_kwh": cfg.general.cost_per_kwh,
-            "teslaMate_url": bool(cfg.teslaMate.database_url),
-            "ha_url": cfg.home_assistant.url,
-            "abrp_configured": bool(cfg.abrp.user_token),
-            "geofences": list(cfg.geofences.zones.keys()),
-            "notifications": cfg.notifications.enabled,
-            "vehicles": cfg.vehicles.aliases,
-            "auth_enabled": bool(cfg.server.api_key),
-        }
+        return _build_config_response(load_config())
 
     @app.get("/api/providers", tags=["System"])
     def api_providers() -> list:
@@ -296,16 +344,7 @@ def _register_system_endpoints(app: FastAPI) -> None:
     @app.get("/api/providers/capabilities", tags=["System"])
     def api_provider_capabilities() -> dict:
         """Capability map — which providers serve which capabilities."""
-        from tesla_cli.core.providers import get_registry
-        from tesla_cli.core.providers.base import Capability
-
-        registry = get_registry()
-        out = {}
-        for cap in sorted(Capability.all()):
-            available = [p.name for p in registry.for_capability(cap)]
-            all_p = [p.name for p in registry.for_capability(cap, available_only=False)]
-            out[cap] = {"available": available, "all": all_p}
-        return out
+        return _build_provider_capabilities()
 
     @app.get("/api/config/validate", tags=["System"])
     def api_config_validate() -> dict:
@@ -313,13 +352,7 @@ def _register_system_endpoints(app: FastAPI) -> None:
 
         Returns {valid, errors, warnings, checks[]} suitable for a dashboard health widget.
         """
-        from tesla_cli.cli.commands.config_cmd import _run_config_checks
-
-        cfg = load_config()
-        checks = _run_config_checks(cfg)
-        errors = sum(1 for c in checks if c["status"] == "error")
-        warnings = sum(1 for c in checks if c["status"] == "warn")
-        return {"valid": errors == 0, "errors": errors, "warnings": warnings, "checks": checks}
+        return _build_config_validation(load_config())
 
 
 def _register_metrics(app: FastAPI) -> None:
@@ -407,6 +440,68 @@ def _register_metrics(app: FastAPI) -> None:
         return PlainTextResponse("".join(lines), media_type="text/plain; version=0.0.4")
 
 
+def _sse_topic_events(data: dict, ts: int, topic_set: set) -> list[str]:
+    """Build optional per-topic SSE event strings for battery/climate/drive/location."""
+    want_battery = "battery" in topic_set
+    want_climate = "climate" in topic_set
+    want_drive = "drive" in topic_set
+    want_location = "location" in topic_set
+
+    events = []
+    if want_battery:
+        cs = data.get("charge_state") or {}
+        events.append(f"event: battery\ndata: {json.dumps({'ts': ts, 'data': _sanitize(cs)})}\n\n")
+    if want_climate:
+        cl = data.get("climate_state") or {}
+        events.append(f"event: climate\ndata: {json.dumps({'ts': ts, 'data': _sanitize(cl)})}\n\n")
+    if want_drive:
+        ds = data.get("drive_state") or {}
+        events.append(f"event: drive\ndata: {json.dumps({'ts': ts, 'data': _sanitize(ds)})}\n\n")
+    if want_location:
+        ds = data.get("drive_state") or {}
+        loc = {
+            "lat": ds.get("latitude"),
+            "lon": ds.get("longitude"),
+            "heading": ds.get("heading"),
+            "speed": ds.get("speed"),
+        }
+        events.append(f"event: location\ndata: {json.dumps({'ts': ts, 'data': loc})}\n\n")
+    return events
+
+
+def _sse_geofence_events(data: dict, ts: int, geofence_state: dict[str, bool]) -> list[str]:
+    """Compute geofence enter/exit SSE events from current vehicle position."""
+    drive = data.get("drive_state") or data.get("response", {}).get("drive_state", {})
+    lat = drive.get("latitude") if isinstance(drive, dict) else None
+    lon = drive.get("longitude") if isinstance(drive, dict) else None
+    if lat is None or lon is None:
+        return []
+
+    events = []
+    reload_cfg = load_config()
+    for name, zone in reload_cfg.geofences.zones.items():
+        dist = _haversine_km(lat, lon, zone["lat"], zone["lon"])
+        inside = dist <= zone.get("radius_km", 0.5)
+        was_inside = geofence_state.get(name)
+        if was_inside is None:
+            geofence_state[name] = inside
+        elif inside != was_inside:
+            geofence_state[name] = inside
+            event = "enter" if inside else "exit"
+            gf_payload = json.dumps(
+                {
+                    "ts": ts,
+                    "zone": name,
+                    "event": event,
+                    "lat": lat,
+                    "lon": lon,
+                    "dist_km": round(dist, 3),
+                }
+            )
+            events.append(f"event: geofence\ndata: {gf_payload}\n\n")
+    return events
+
+
 def _register_sse_stream(app: FastAPI) -> None:
     """Register the real-time SSE vehicle stream endpoint."""
 
@@ -435,15 +530,9 @@ def _register_sse_stream(app: FastAPI) -> None:
         cfg = load_config()
         v = resolve_vin(cfg, app.state.override_vin)
         topic_set = {t.strip() for t in topics.split(",") if t.strip()}
-        want_geofence = "geofence" in topic_set
-        want_battery = "battery" in topic_set
-        want_climate = "climate" in topic_set
-        want_drive = "drive" in topic_set
-        want_location = "location" in topic_set
         geofence_state: dict[str, bool] = {}  # zone_name → was_inside
 
         async def _generate():
-            nonlocal geofence_state
             backend = get_vehicle_backend(cfg)
             while True:
                 if await request.is_disconnected():
@@ -453,69 +542,20 @@ def _register_sse_stream(app: FastAPI) -> None:
                         None, lambda: backend.get_vehicle_data(v)
                     )
                     ts = int(time.time())
-                    payload = json.dumps(
-                        {
-                            "ts": ts,
-                            "data": _sanitize(data),
-                        }
-                    )
+                    payload = json.dumps({"ts": ts, "data": _sanitize(data)})
                     yield f"event: vehicle\ndata: {payload}\n\n"
 
-                    if want_battery:
-                        cs = data.get("charge_state") or {}
-                        yield f"event: battery\ndata: {json.dumps({'ts': ts, 'data': _sanitize(cs)})}\n\n"
-
-                    if want_climate:
-                        cl = data.get("climate_state") or {}
-                        yield f"event: climate\ndata: {json.dumps({'ts': ts, 'data': _sanitize(cl)})}\n\n"
-
-                    if want_drive:
-                        ds = data.get("drive_state") or {}
-                        yield f"event: drive\ndata: {json.dumps({'ts': ts, 'data': _sanitize(ds)})}\n\n"
-
-                    if want_location:
-                        ds = data.get("drive_state") or {}
-                        loc = {
-                            "lat": ds.get("latitude"),
-                            "lon": ds.get("longitude"),
-                            "heading": ds.get("heading"),
-                            "speed": ds.get("speed"),
-                        }
-                        yield f"event: location\ndata: {json.dumps({'ts': ts, 'data': loc})}\n\n"
+                    for ev in _sse_topic_events(data, ts, topic_set):
+                        yield ev
 
                     if fanout:
                         await asyncio.get_event_loop().run_in_executor(
                             None, _fanout_telemetry, data, v, cfg
                         )
 
-                    if want_geofence:
-                        drive = data.get("drive_state") or data.get("response", {}).get(
-                            "drive_state", {}
-                        )
-                        lat = drive.get("latitude") if isinstance(drive, dict) else None
-                        lon = drive.get("longitude") if isinstance(drive, dict) else None
-                        if lat is not None and lon is not None:
-                            reload_cfg = load_config()
-                            for name, zone in reload_cfg.geofences.zones.items():
-                                dist = _haversine_km(lat, lon, zone["lat"], zone["lon"])
-                                inside = dist <= zone.get("radius_km", 0.5)
-                                was_inside = geofence_state.get(name)
-                                if was_inside is None:
-                                    geofence_state[name] = inside
-                                elif inside != was_inside:
-                                    geofence_state[name] = inside
-                                    event = "enter" if inside else "exit"
-                                    gf_payload = json.dumps(
-                                        {
-                                            "ts": ts,
-                                            "zone": name,
-                                            "event": event,
-                                            "lat": lat,
-                                            "lon": lon,
-                                            "dist_km": round(dist, 3),
-                                        }
-                                    )
-                                    yield f"event: geofence\ndata: {gf_payload}\n\n"
+                    if "geofence" in topic_set:
+                        for ev in _sse_geofence_events(data, ts, geofence_state):
+                            yield ev
 
                 except Exception as exc:  # noqa: BLE001
                     yield f"event: vehicle\ndata: {json.dumps({'error': str(exc)})}\n\n"

tesla_cli-4.9.0/src/tesla_cli/api/routes/abrp.py

@@ -0,0 +1,73 @@
+"""ABRP API routes: /api/abrp/*"""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException, Request
+
+from tesla_cli.core.config import load_config, resolve_vin
+
+router = APIRouter()
+
+_ABRP_API = "https://api.iternio.com/1/tlm/send"
+
+
+@router.get("/status")
+def abrp_status() -> dict:
+    """ABRP connection status and configuration."""
+    cfg = load_config()
+    return {
+        "user_token_set": bool(cfg.abrp.user_token),
+        "api_key_set": bool(cfg.abrp.api_key),
+        "configured": bool(cfg.abrp.user_token),
+        "abrp_api": _ABRP_API,
+    }
+
+
+@router.get("/config")
+def abrp_config() -> dict:
+    """Get ABRP configuration (api_key configured, user_token set)."""
+    cfg = load_config()
+    return {
+        "user_token_set": bool(cfg.abrp.user_token),
+        "api_key_set": bool(cfg.abrp.api_key),
+        "abrp_api": _ABRP_API,
+    }
+
+
+@router.post("/send")
+def abrp_send(request: Request) -> dict:
+    """Send current vehicle telemetry to ABRP."""
+    cfg = load_config()
+
+    if not cfg.abrp.user_token:
+        raise HTTPException(
+            status_code=400,
+            detail="ABRP user token not configured. Run: tesla config set abrp-user-token <TOKEN>",
+        )
+
+    try:
+        from tesla_cli.core.backends import get_vehicle_backend
+
+        v = resolve_vin(cfg, request.app.state.override_vin)
+        backend = get_vehicle_backend(cfg)
+        data = backend.get_vehicle_data(v)
+    except Exception as exc:
+        raise HTTPException(status_code=502, detail=f"Failed to get vehicle data: {exc}")
+
+    try:
+        from tesla_cli.core.providers.impl.abrp import AbrpProvider
+
+        provider = AbrpProvider(cfg)
+        result = provider.execute("push", data=data)
+        if not result.ok:
+            raise HTTPException(status_code=502, detail=result.error or "ABRP push failed")
+        return {
+            "ok": True,
+            "telemetry": result.data.get("tlm") if result.data else {},
+            "abrp_response": result.data.get("response") if result.data else {},
+            "latency_ms": result.latency_ms,
+        }
+    except HTTPException:
+        raise
+    except Exception as exc:
+        raise HTTPException(status_code=502, detail=str(exc))