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

tescmd/openclaw/telemetry_store.py

@@ -0,0 +1,53 @@
+"""In-memory store for the latest telemetry values per field.
+
+Used by :class:`CommandDispatcher` to serve read requests from cached
+telemetry data before falling back to the Fleet API. Updated on every
+decoded frame by :class:`TelemetryBridge`.
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from datetime import datetime
+
+
+@dataclass(slots=True)
+class FieldSnapshot:
+    """A single telemetry field's most recent value."""
+
+    value: Any
+    timestamp: datetime
+
+
+class TelemetryStore:
+    """Thread-safe (single-event-loop) store of latest telemetry values.
+
+    Keyed by the Tesla Fleet Telemetry field name (e.g. ``"Soc"``,
+    ``"Location"``, ``"Locked"``).
+    """
+
+    def __init__(self) -> None:
+        self._data: dict[str, FieldSnapshot] = {}
+
+    def update(self, field_name: str, value: Any, timestamp: datetime) -> None:
+        """Record or overwrite the latest value for *field_name*."""
+        self._data[field_name] = FieldSnapshot(value=value, timestamp=timestamp)
+
+    def get(self, field_name: str) -> FieldSnapshot | None:
+        """Return the latest snapshot for *field_name*, or ``None``."""
+        return self._data.get(field_name)
+
+    def get_all(self) -> dict[str, FieldSnapshot]:
+        """Return a shallow copy of all current snapshots."""
+        return dict(self._data)
+
+    def age_seconds(self, field_name: str) -> float | None:
+        """Return seconds since *field_name* was last updated, or ``None``."""
+        snap = self._data.get(field_name)
+        if snap is None:
+            return None
+        return time.time() - snap.timestamp.timestamp()

tescmd/output/rich_output.py

@@ -214,11 +214,29 @@ class RichOutput:
 
     def vehicle_release_notes(self, data: dict[str, Any]) -> None:
         """Display firmware release notes."""
-        self._dict_table(
-            "Release Notes",
-            data,
-            empty_msg="[dim]No release notes available.[/dim]",
-        )
+        version = data.get("deployed_version") or data.get("release_notes_version", "")
+        notes = data.get("release_notes", [])
+
+        if not notes:
+            self._con.print("[dim]No release notes available.[/dim]")
+            return
+
+        if version:
+            self._con.print(f"[bold]Release Notes — {version}[/bold]")
+            self._con.print()
+
+        for note in notes:
+            if not isinstance(note, dict):
+                self._con.print(f"  {note}")
+                continue
+            title = note.get("title", "")
+            desc = note.get("description", "")
+            if title:
+                self._con.print(f"[bold cyan]{title}[/bold cyan]")
+            if desc:
+                for line in desc.strip().splitlines():
+                    self._con.print(f"  {line.strip()}")
+                self._con.print()
 
     # ------------------------------------------------------------------
     # Vehicle list
@@ -339,10 +357,14 @@ class RichOutput:
         ):
             rows.append(("Time to full", f"{cs.time_to_full_charge:.1f}h"))
         if cs.scheduled_charging_start_time is not None:
+            from datetime import UTC
+
             rows.append(
                 (
                     "Scheduled start",
-                    datetime.fromtimestamp(cs.scheduled_charging_start_time).strftime("%I:%M %p"),
+                    datetime.fromtimestamp(cs.scheduled_charging_start_time, tz=UTC)
+                    .astimezone()
+                    .strftime("%I:%M %p"),
                 )
             )
         if cs.scheduled_departure_time_minutes is not None:
@@ -410,27 +432,37 @@ class RichOutput:
     # ------------------------------------------------------------------
 
     def location(self, ds: DriveState) -> None:
-        """Print a table of drive-state / location fields."""
+        """Print a table of GPS location fields."""
         table = Table(title="Location")
         table.add_column("Field", style="bold")
         table.add_column("Value")
 
         if ds.latitude is not None and ds.longitude is not None:
-            table.add_row("Coordinates", f"{ds.latitude}, {ds.longitude}")
+            table.add_row("Latitude", str(ds.latitude))
+            table.add_row("Longitude", str(ds.longitude))
         if ds.heading is not None:
             table.add_row("Heading", f"{ds.heading}\u00b0")
-        if ds.shift_state:
-            table.add_row("Gear", ds.shift_state)
-        if ds.speed is not None:
-            table.add_row("Speed", self._fmt_speed(ds.speed))
-        if ds.power is not None:
-            table.add_row("Power", f"{ds.power} kW")
         if ds.timestamp is not None:
             table.add_row(
                 "Updated",
                 datetime.fromtimestamp(ds.timestamp / 1000).strftime("%Y-%m-%d %H:%M:%S"),
             )
 
+        # Show any additional location fields from the API (extra="allow")
+        _known = {
+            "latitude",
+            "longitude",
+            "heading",
+            "timestamp",
+            "shift_state",
+            "speed",
+            "power",
+        }
+        for key, value in sorted((ds.model_extra or {}).items()):
+            if key not in _known and value is not None:
+                label = key.replace("_", " ").title()
+                table.add_row(label, str(value))
+
         self._con.print(table)
 
     # ------------------------------------------------------------------

tescmd/protocol/commands.py

@@ -100,7 +100,7 @@ _INFOTAINMENT_COMMANDS: dict[str, CommandSpec] = {
     "set_pin_to_drive": CommandSpec(Domain.DOMAIN_INFOTAINMENT),
     "guest_mode": CommandSpec(Domain.DOMAIN_INFOTAINMENT),
     "erase_user_data": CommandSpec(Domain.DOMAIN_INFOTAINMENT),
-    "remote_boombox": CommandSpec(Domain.DOMAIN_INFOTAINMENT, requires_signing=False),
+    "remote_boombox": CommandSpec(Domain.DOMAIN_INFOTAINMENT),
     # Media
     "media_toggle_playback": CommandSpec(Domain.DOMAIN_INFOTAINMENT),
     "media_next_track": CommandSpec(Domain.DOMAIN_INFOTAINMENT),
@@ -121,7 +121,7 @@ _INFOTAINMENT_COMMANDS: dict[str, CommandSpec] = {
     "cancel_software_update": CommandSpec(Domain.DOMAIN_INFOTAINMENT),
     # Vehicle name / calendar
     "set_vehicle_name": CommandSpec(Domain.DOMAIN_INFOTAINMENT),
-    "upcoming_calendar_entries": CommandSpec(Domain.DOMAIN_INFOTAINMENT),
+    "upcoming_calendar_entries": CommandSpec(Domain.DOMAIN_INFOTAINMENT, requires_signing=False),
     # Windows / sunroof
     "window_control": CommandSpec(Domain.DOMAIN_INFOTAINMENT),
     "sun_roof_control": CommandSpec(Domain.DOMAIN_INFOTAINMENT),

tescmd/protocol/encoder.py

@@ -38,7 +38,7 @@ def build_session_info_request(
     """
     return RoutableMessage(
         to_destination=Destination(domain=domain),
-        from_destination=Destination(routing_address=client_public_key),
+        from_destination=Destination(routing_address=os.urandom(16)),
         session_info_request=SessionInfoRequest(public_key=client_public_key),
         uuid=os.urandom(16),
     )
@@ -80,7 +80,7 @@ def build_signed_command(
     """
     return RoutableMessage(
         to_destination=Destination(domain=domain),
-        from_destination=Destination(routing_address=client_public_key),
+        from_destination=Destination(routing_address=os.urandom(16)),
         protobuf_message_as_bytes=payload,
         signature_data=SignatureData(
             signer_identity=KeyIdentity(public_key=client_public_key),
@@ -100,23 +100,26 @@ def encode_routable_message(msg: RoutableMessage) -> str:
     return base64.b64encode(msg.serialize()).decode("ascii")
 
 
-def default_expiry(clock_offset: int = 0, ttl_seconds: int = 15) -> int:
+def default_expiry(time_zero: float = 0.0, ttl_seconds: int = 15) -> int:
     """Return a command expiry timestamp in the vehicle's epoch-relative time.
 
-    The Go SDK computes ``ExpiresAt = clockTime + elapsed + TTL`` where
-    ``clockTime`` comes from the vehicle's SessionInfo.  Our Session stores
-    ``clock_offset = clockTime - local_time_at_handshake``, so::
+    The Go SDK computes::
 
-        expires_at = now + clock_offset + TTL
-                   = now + (clockTime - handshake_time) + TTL
-                   ≈ clockTime + TTL   (when sent shortly after handshake)
+        ExpiresAt = uint32(time.Now().Add(expiresIn).Sub(s.timeZero) / time.Second)
+
+    Where ``timeZero`` is the wall-clock instant when the vehicle's epoch
+    counter was zero (``now - clockTime`` at handshake time).  So::
+
+        expires_at = (now + TTL - time_zero)
+                   = (now + TTL - (handshake_time - clockTime))
+                   ≈ clockTime + TTL   (vehicle-relative seconds)
 
     Parameters
     ----------
-    clock_offset:
-        ``session.clock_offset`` — the difference between the vehicle's
-        epoch clock and the local wall clock at handshake time.
+    time_zero:
+        ``session.time_zero`` — the wall-clock time corresponding to epoch
+        counter 0 on the vehicle.
     ttl_seconds:
         Time-to-live in seconds (default 15).
     """
-    return int(time.time()) + clock_offset + ttl_seconds
+    return int(time.time() + ttl_seconds - time_zero)

tescmd/protocol/payloads.py

@@ -64,6 +64,7 @@ _CLOSURE_CLOSE = 4
 _CLOSURE_REAR_TRUNK = 5
 _CLOSURE_FRONT_TRUNK = 6
 _CLOSURE_CHARGE_PORT = 7
+_CLOSURE_TONNEAU = 8
 
 
 def _vcsec_rke(action: int) -> bytes:
@@ -141,8 +142,18 @@ _VA_ADD_CHARGE_SCHEDULE = 97
 _VA_REMOVE_CHARGE_SCHEDULE = 98
 _VA_ADD_PRECONDITION_SCHEDULE = 99
 _VA_REMOVE_PRECONDITION_SCHEDULE = 100
+_VA_BOOMBOX = 64  # VehicleControlRemoteBoomboxAction
 _VA_BATCH_REMOVE_PRECONDITION = 107
 _VA_BATCH_REMOVE_CHARGE = 108
+_VA_SET_LOW_POWER_MODE = 130
+_VA_KEEP_ACCESSORY_POWER = 138
+
+# Navigation (from Teslemetry's extended proto — not in Tesla's published proto)
+# https://github.com/Teslemetry/python-tesla-fleet-api/blob/main/proto/car_server.proto
+_VA_NAVIGATION_REQUEST = 21
+_VA_NAVIGATION_SC_REQUEST = 22
+_VA_NAVIGATION_GPS_REQUEST = 53
+_VA_NAVIGATION_WAYPOINTS_REQUEST = 90
 
 
 # ---------------------------------------------------------------------------
@@ -425,17 +436,14 @@ def _bioweapon_mode(body: dict[str, Any]) -> bytes:
 
 
 def _window_control(body: dict[str, Any]) -> bytes:
-    """VehicleControlWindowAction — vent or close."""
-    command = body.get("command", "vent")
-    field = 2 if command == "close" else 1
-    inner = _encode_varint_field(field, 1)
-    # lat/lon may be required for window control
-    if "lat" in body and "lon" in body:
-        import struct
+    """VehicleControlWindowAction — vent (field 3) or close (field 4).
 
-        location = _encode_tag_raw(3, 5) + struct.pack("<f", float(body["lat"]))
-        location += _encode_tag_raw(4, 5) + struct.pack("<f", float(body["lon"]))
-        inner += location
+    Per Tesla's proto, field 1 is reserved (location removed) and the
+    action is a oneof of Void fields: vent=3, close=4.
+    """
+    command = body.get("command", "vent")
+    field = 4 if command == "close" else 3
+    inner = _encode_length_delimited(field, _VOID)
     return _wrap_vehicle_action(_VA_WINDOW_CONTROL, inner)
 
 
@@ -458,6 +466,14 @@ def _erase_user_data(_body: dict[str, Any]) -> bytes:
     return _void_vehicle_action(_VA_ERASE_USER_DATA)
 
 
+def _remote_boombox(body: dict[str, Any]) -> bytes:
+    """VehicleControlRemoteBoomboxAction: action (field 1, uint32)."""
+    # CLI sends {"sound": id}, protobuf field is "action"
+    action = body.get("sound", body.get("action", 0))
+    inner = _encode_varint_field(1, int(action))
+    return _wrap_vehicle_action(_VA_BOOMBOX, inner)
+
+
 def _scheduled_charging(body: dict[str, Any]) -> bytes:
     """ScheduledChargingAction."""
     inner = b""
@@ -518,6 +534,98 @@ def _steering_wheel_heat_level(body: dict[str, Any]) -> bytes:
     return _wrap_vehicle_action(_VA_HVAC_STEERING_WHEEL_HEATER, inner)
 
 
+def _set_low_power_mode(body: dict[str, Any]) -> bytes:
+    """SetLowPowerModeAction: low_power_mode (field 1, bool)."""
+    on = body.get("enable", True)
+    inner = _encode_varint_field(1, 1 if on else 0)
+    return _wrap_vehicle_action(_VA_SET_LOW_POWER_MODE, inner)
+
+
+def _keep_accessory_power_mode(body: dict[str, Any]) -> bytes:
+    """SetKeepAccessoryPowerModeAction: keep_accessory_power_mode (field 1, bool)."""
+    on = body.get("enable", True)
+    inner = _encode_varint_field(1, 1 if on else 0)
+    return _wrap_vehicle_action(_VA_KEEP_ACCESSORY_POWER, inner)
+
+
+def _batch_remove_precondition_schedules(body: dict[str, Any]) -> bytes:
+    """BatchRemovePreconditionSchedulesAction: home(1), work(2), other(3)."""
+    inner = b""
+    if body.get("home"):
+        inner += _encode_varint_field(1, 1)
+    if body.get("work"):
+        inner += _encode_varint_field(2, 1)
+    if body.get("other"):
+        inner += _encode_varint_field(3, 1)
+    return _wrap_vehicle_action(_VA_BATCH_REMOVE_PRECONDITION, inner)
+
+
+def _batch_remove_charge_schedules(body: dict[str, Any]) -> bytes:
+    """BatchRemoveChargeSchedulesAction: home(1), work(2), other(3)."""
+    inner = b""
+    if body.get("home"):
+        inner += _encode_varint_field(1, 1)
+    if body.get("work"):
+        inner += _encode_varint_field(2, 1)
+    if body.get("other"):
+        inner += _encode_varint_field(3, 1)
+    return _wrap_vehicle_action(_VA_BATCH_REMOVE_CHARGE, inner)
+
+
+# ---------------------------------------------------------------------------
+# Navigation payload builders
+# ---------------------------------------------------------------------------
+
+
+def _navigation_request(body: dict[str, Any]) -> bytes:
+    """NavigationRequest: destination (field 1, string), order (field 2, int32).
+
+    The CLI ``nav send`` command passes ``{"address": "..."}``.  The REST
+    ``share`` endpoint wraps this in an Android intent JSON, but the VCP
+    proto only needs the destination string.
+    """
+    inner = b""
+    destination = body.get("address", body.get("destination", ""))
+    if destination:
+        inner += _encode_length_delimited(1, str(destination).encode())
+    order = body.get("order")
+    if order is not None:
+        inner += _encode_varint_field(2, int(order))
+    return _wrap_vehicle_action(_VA_NAVIGATION_REQUEST, inner)
+
+
+def _navigation_sc_request(body: dict[str, Any]) -> bytes:
+    """NavigationSuperchargerRequest: order (field 1, int32)."""
+    order = body.get("order", 1)
+    inner = _encode_varint_field(1, int(order))
+    return _wrap_vehicle_action(_VA_NAVIGATION_SC_REQUEST, inner)
+
+
+def _navigation_gps_request(body: dict[str, Any]) -> bytes:
+    """NavigationGpsRequest: lat (1, double), lon (2, double), order (3, enum)."""
+    import struct
+
+    inner = b""
+    lat = body.get("lat", 0.0)
+    lon = body.get("lon", 0.0)
+    # Protobuf double = wire type 1 (fixed 64-bit)
+    inner += _encode_tag_raw(1, 1) + struct.pack("<d", float(lat))
+    inner += _encode_tag_raw(2, 1) + struct.pack("<d", float(lon))
+    order = body.get("order")
+    if order is not None:
+        inner += _encode_varint_field(3, int(order))
+    return _wrap_vehicle_action(_VA_NAVIGATION_GPS_REQUEST, inner)
+
+
+def _navigation_waypoints_request(body: dict[str, Any]) -> bytes:
+    """NavigationWaypointsRequest: waypoints (field 1, string)."""
+    inner = b""
+    waypoints = body.get("waypoints", "")
+    if waypoints:
+        inner += _encode_length_delimited(1, str(waypoints).encode())
+    return _wrap_vehicle_action(_VA_NAVIGATION_WAYPOINTS_REQUEST, inner)
+
+
 # ---------------------------------------------------------------------------
 # Builder registry — maps REST command names to payload builder functions
 # ---------------------------------------------------------------------------
@@ -529,7 +637,11 @@ _BUILDERS: dict[str, _PayloadBuilder] = {
     "door_lock": lambda _: _vcsec_rke(_RKE_LOCK),
     "door_unlock": lambda _: _vcsec_rke(_RKE_UNLOCK),
     "remote_start_drive": lambda _: _vcsec_rke(_RKE_REMOTE_DRIVE),
+    "auto_secure_vehicle": lambda _: _vcsec_rke(_RKE_AUTO_SECURE),
     "actuate_trunk": lambda body: _build_trunk_payload(body),
+    "open_tonneau": lambda _: _vcsec_closure_move(**{str(_CLOSURE_TONNEAU): _CLOSURE_OPEN}),
+    "close_tonneau": lambda _: _vcsec_closure_move(**{str(_CLOSURE_TONNEAU): _CLOSURE_CLOSE}),
+    "stop_tonneau": lambda _: _vcsec_closure_move(**{str(_CLOSURE_TONNEAU): _CLOSURE_STOP}),
     # Infotainment commands → Action { VehicleAction } payloads
     "charge_start": _charging_start,
     "charge_stop": _charging_stop,
@@ -545,6 +657,8 @@ _BUILDERS: dict[str, _PayloadBuilder] = {
     "remove_charge_schedule": _remove_charge_schedule,
     "add_precondition_schedule": _add_precondition_schedule,
     "remove_precondition_schedule": _remove_precondition_schedule,
+    "batch_remove_precondition_schedules": _batch_remove_precondition_schedules,
+    "batch_remove_charge_schedules": _batch_remove_charge_schedules,
     # Climate
     "auto_conditioning_start": _hvac_auto_start,
     "auto_conditioning_stop": _hvac_auto_stop,
@@ -576,7 +690,7 @@ _BUILDERS: dict[str, _PayloadBuilder] = {
     "set_pin_to_drive": _set_pin_to_drive,
     "guest_mode": _guest_mode,
     "erase_user_data": _erase_user_data,
-    "remote_boombox": lambda _: _void_vehicle_action(_VA_HONK_HORN),  # Maps to honk
+    "remote_boombox": _remote_boombox,
     # Media
     "media_toggle_playback": lambda _: _void_vehicle_action(_VA_MEDIA_PLAY),
     "media_next_track": lambda _: _void_vehicle_action(_VA_MEDIA_NEXT_TRACK),
@@ -591,6 +705,10 @@ _BUILDERS: dict[str, _PayloadBuilder] = {
     ),
     "adjust_volume": _media_volume,
     # Navigation
+    "share": _navigation_request,
+    "navigation_gps_request": _navigation_gps_request,
+    "navigation_sc_request": _navigation_sc_request,
+    "navigation_waypoints_request": _navigation_waypoints_request,
     "trigger_homelink": _trigger_homelink,
     # Software
     "schedule_software_update": _schedule_software_update,
@@ -601,6 +719,9 @@ _BUILDERS: dict[str, _PayloadBuilder] = {
     "sun_roof_control": _sunroof,
     # Window (infotainment path)
     "window_control": _window_control,
+    # Power management
+    "set_low_power_mode": _set_low_power_mode,
+    "keep_accessory_power_mode": _keep_accessory_power_mode,
 }
 
 

tescmd/protocol/session.py

@@ -63,7 +63,7 @@ class Session:
     session_info_key: bytes
     epoch: bytes
     counter: int
-    clock_offset: int  # vehicle_clock - local_clock (seconds)
+    time_zero: float  # wall-clock time when the vehicle's epoch counter was 0
     created_at: float
     ttl: float = _SESSION_TTL
 
@@ -308,9 +308,12 @@ class SessionManager:
                 "The vehicle response may have been tampered with."
             )
 
-        # Calculate clock offset
-        local_time = int(time.time())
-        clock_offset = session_info.clock_time - local_time if session_info.clock_time else 0
+        # Reconstruct the wall-clock instant when the vehicle's epoch counter
+        # was zero.  The Go SDK does: timeZero = now - Duration(clockTime).
+        # clock_time is a monotonic uptime counter (seconds since the
+        # vehicle's security module last booted), NOT a Unix timestamp.
+        now = time.time()
+        time_zero = now - session_info.clock_time if session_info.clock_time else now
 
         return Session(
             vin=vin,
@@ -320,6 +323,6 @@ class SessionManager:
             session_info_key=session_info_key,
             epoch=session_info.epoch,
             counter=session_info.counter,
-            clock_offset=clock_offset,
+            time_zero=time_zero,
             created_at=time.monotonic(),
         )

tescmd/protocol/signer.py

@@ -5,8 +5,7 @@ Signing flow (for the REST/Fleet API path):
 1. Serialize metadata as TLV: ``encode_metadata(epoch, expires_at, counter)``
 2. Derive signing key: ``K' = HMAC-SHA256(K, b"authenticated command")``
 3. Compute tag: ``HMAC-SHA256(K', metadata_bytes || 0xFF || payload_bytes)``
-4. For VCSEC domain: truncate tag to 17 bytes.
-5. Attach to ``RoutableMessage.signature_data.HMAC_PersonalizedData.tag``
+4. Attach to ``RoutableMessage.signature_data.HMAC_PersonalizedData.tag``
 """
 
 from __future__ import annotations
@@ -14,15 +13,10 @@ from __future__ import annotations
 import hashlib
 import hmac
 
-from tescmd.protocol.protobuf.messages import Domain
-
 # Derivation labels (from Tesla vehicle-command specification)
 _LABEL_AUTHENTICATED_COMMAND = b"authenticated command"
 _LABEL_SESSION_INFO = b"session info"
 
-# VCSEC domain uses a truncated 17-byte tag
-_VCSEC_TAG_LENGTH = 17
-
 
 def derive_signing_key(session_key: bytes) -> bytes:
     """Derive the command signing key: ``HMAC-SHA256(K, "authenticated command")``."""
@@ -38,8 +32,6 @@ def compute_hmac_tag(
     signing_key: bytes,
     metadata_bytes: bytes,
     payload_bytes: bytes,
-    *,
-    domain: Domain = Domain.DOMAIN_INFOTAINMENT,
 ) -> bytes:
     """Compute the HMAC-SHA256 authentication tag.
 
@@ -51,24 +43,18 @@ def compute_hmac_tag(
         TLV-encoded metadata (epoch, expires_at, counter, flags).
     payload_bytes:
         The serialized protobuf command payload.
-    domain:
-        The routing domain — VCSEC tags are truncated to 17 bytes.
 
     Returns
     -------
     bytes
-        The HMAC tag (32 bytes for Infotainment, 17 bytes for VCSEC).
+        The full 32-byte HMAC-SHA256 tag.
     """
     # The Go SDK streams metadata entries into the hash, then Checksum()
     # writes a bare TAG_END byte (0xFF) before the payload — no length byte.
     #   m.Context.Write([]byte{byte(signatures.Tag_TAG_END)})  // just 0xFF
     #   m.Context.Write(message)
     msg = metadata_bytes + b"\xff" + payload_bytes
-    tag = hmac.new(signing_key, msg, hashlib.sha256).digest()
-
-    if domain == Domain.DOMAIN_VEHICLE_SECURITY:
-        return tag[:_VCSEC_TAG_LENGTH]
-    return tag
+    return hmac.new(signing_key, msg, hashlib.sha256).digest()
 
 
 def verify_session_info_tag(

tescmd/telemetry/__init__.py

@@ -2,18 +2,27 @@
 
 from __future__ import annotations
 
+from tescmd.telemetry.cache_sink import CacheSink
 from tescmd.telemetry.decoder import TelemetryDatum, TelemetryDecoder, TelemetryFrame
+from tescmd.telemetry.fanout import FrameFanout
 from tescmd.telemetry.fields import FIELD_NAMES, PRESETS, resolve_fields
+from tescmd.telemetry.mapper import TelemetryMapper
 from tescmd.telemetry.server import TelemetryServer
+from tescmd.telemetry.setup import TelemetrySession, telemetry_session
 from tescmd.telemetry.tailscale import TailscaleManager
 
 __all__ = [
     "FIELD_NAMES",
     "PRESETS",
+    "CacheSink",
+    "FrameFanout",
     "TailscaleManager",
     "TelemetryDatum",
     "TelemetryDecoder",
     "TelemetryFrame",
+    "TelemetryMapper",
     "TelemetryServer",
+    "TelemetrySession",
     "resolve_fields",
+    "telemetry_session",
 ]