tescmd 0.1.2__py3-none-any.whl

tescmd/cli/media.py

@@ -0,0 +1,146 @@
+"""CLI commands for media playback control."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import click
+
+from tescmd._internal.async_utils import run_async
+from tescmd.cli._client import execute_command
+from tescmd.cli._options import global_options
+
+if TYPE_CHECKING:
+    from tescmd.cli.main import AppContext
+
+media_group = click.Group("media", help="Media playback commands")
+
+
+@media_group.command("play-pause")
+@click.argument("vin_positional", required=False, default=None, metavar="VIN")
+@global_options
+def play_pause_cmd(app_ctx: AppContext, vin_positional: str | None) -> None:
+    """Toggle media playback."""
+    run_async(
+        execute_command(
+            app_ctx,
+            vin_positional,
+            "media_toggle_playback",
+            "media.play-pause",
+            success_message="Media playback toggled.",
+        )
+    )
+
+
+@media_group.command("next-track")
+@click.argument("vin_positional", required=False, default=None, metavar="VIN")
+@global_options
+def next_track_cmd(app_ctx: AppContext, vin_positional: str | None) -> None:
+    """Skip to next track."""
+    run_async(
+        execute_command(
+            app_ctx,
+            vin_positional,
+            "media_next_track",
+            "media.next-track",
+            success_message="Skipped to next track.",
+        )
+    )
+
+
+@media_group.command("prev-track")
+@click.argument("vin_positional", required=False, default=None, metavar="VIN")
+@global_options
+def prev_track_cmd(app_ctx: AppContext, vin_positional: str | None) -> None:
+    """Skip to previous track."""
+    run_async(
+        execute_command(
+            app_ctx,
+            vin_positional,
+            "media_prev_track",
+            "media.prev-track",
+            success_message="Skipped to previous track.",
+        )
+    )
+
+
+@media_group.command("next-fav")
+@click.argument("vin_positional", required=False, default=None, metavar="VIN")
+@global_options
+def next_fav_cmd(app_ctx: AppContext, vin_positional: str | None) -> None:
+    """Skip to next favourite."""
+    run_async(
+        execute_command(
+            app_ctx,
+            vin_positional,
+            "media_next_fav",
+            "media.next-fav",
+            success_message="Skipped to next favorite.",
+        )
+    )
+
+
+@media_group.command("prev-fav")
+@click.argument("vin_positional", required=False, default=None, metavar="VIN")
+@global_options
+def prev_fav_cmd(app_ctx: AppContext, vin_positional: str | None) -> None:
+    """Skip to previous favourite."""
+    run_async(
+        execute_command(
+            app_ctx,
+            vin_positional,
+            "media_prev_fav",
+            "media.prev-fav",
+            success_message="Skipped to previous favorite.",
+        )
+    )
+
+
+@media_group.command("volume-up")
+@click.argument("vin_positional", required=False, default=None, metavar="VIN")
+@global_options
+def volume_up_cmd(app_ctx: AppContext, vin_positional: str | None) -> None:
+    """Increase volume by one step."""
+    run_async(
+        execute_command(
+            app_ctx,
+            vin_positional,
+            "media_volume_up",
+            "media.volume-up",
+            success_message="Volume increased.",
+        )
+    )
+
+
+@media_group.command("volume-down")
+@click.argument("vin_positional", required=False, default=None, metavar="VIN")
+@global_options
+def volume_down_cmd(app_ctx: AppContext, vin_positional: str | None) -> None:
+    """Decrease volume by one step."""
+    run_async(
+        execute_command(
+            app_ctx,
+            vin_positional,
+            "media_volume_down",
+            "media.volume-down",
+            success_message="Volume decreased.",
+        )
+    )
+
+
+@media_group.command("adjust-volume")
+@click.argument("vin_positional", required=False, default=None, metavar="VIN")
+@click.argument("volume", type=click.FloatRange(0.0, 11.0))
+@global_options
+def adjust_volume_cmd(app_ctx: AppContext, vin_positional: str | None, volume: float) -> None:
+    """Set volume to VOLUME (0.0-11.0)."""
+    run_async(
+        execute_command(
+            app_ctx,
+            vin_positional,
+            "adjust_volume",
+            "media.adjust-volume",
+            body={"volume": volume},
+            success_message=f"Volume set to {volume}.",
+        )
+    )

tescmd/cli/nav.py

@@ -0,0 +1,242 @@
+"""CLI commands for navigation."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import click
+
+from tescmd._internal.async_utils import run_async
+from tescmd.cli._client import (
+    auto_wake,
+    cached_vehicle_data,
+    execute_command,
+    get_command_api,
+    get_vehicle_api,
+    invalidate_cache_for_vin,
+    require_vin,
+)
+from tescmd.cli._options import global_options
+
+if TYPE_CHECKING:
+    from tescmd.cli.main import AppContext
+
+nav_group = click.Group("nav", help="Navigation commands")
+
+
+@nav_group.command("send")
+@click.argument("vin_positional", required=False, default=None, metavar="VIN")
+@click.argument("address", nargs=-1, required=True)
+@global_options
+def send_cmd(app_ctx: AppContext, vin_positional: str | None, address: tuple[str, ...]) -> None:
+    """Send an address to the vehicle navigation.
+
+    ADDRESS is the destination address (multiple words allowed).
+    """
+    full_address = " ".join(address)
+    run_async(
+        execute_command(
+            app_ctx,
+            vin_positional,
+            "share",
+            "nav.send",
+            body={"address": full_address},
+            success_message="Destination sent to vehicle.",
+        )
+    )
+
+
+@nav_group.command("gps")
+@click.argument("vin_positional", required=False, default=None, metavar="VIN")
+@click.argument("coords", nargs=-1, required=True)
+@click.option("--order", type=int, default=None, help="Waypoint order (auto-increments for multi)")
+@global_options
+def gps_cmd(
+    app_ctx: AppContext,
+    vin_positional: str | None,
+    coords: tuple[str, ...],
+    order: int | None,
+) -> None:
+    """Navigate to GPS coordinates.
+
+    Accepts coordinates as LAT LON pairs or as comma-separated LAT,LON strings.
+
+    Single point::
+
+        tescmd nav gps 37.7749 122.4194
+        tescmd nav gps 37.7749,122.4194
+        tescmd nav gps 37.7749 122.4194 --order 1
+
+    Multi-stop route (auto-ordered)::
+
+        tescmd nav gps 37.7749,122.4194 37.3382,121.8863
+    """
+    run_async(_cmd_gps(app_ctx, vin_positional, coords, order))
+
+
+def _parse_coords(coords: tuple[str, ...]) -> list[tuple[float, float]]:
+    """Parse coordinate arguments into (lat, lon) pairs.
+
+    Accepts either space-separated ``LAT LON`` pairs or comma-separated
+    ``LAT,LON`` strings (or a mix).
+    """
+    points: list[tuple[float, float]] = []
+    i = 0
+    while i < len(coords):
+        token = coords[i]
+        if "," in token:
+            parts = token.split(",", 1)
+            points.append((float(parts[0]), float(parts[1])))
+            i += 1
+        elif i + 1 < len(coords) and "," not in coords[i + 1]:
+            points.append((float(token), float(coords[i + 1])))
+            i += 2
+        else:
+            raise click.UsageError(f"Invalid coordinate: {token!r}. Use 'LAT LON' or 'LAT,LON'.")
+    return points
+
+
+async def _cmd_gps(
+    app_ctx: AppContext,
+    vin_positional: str | None,
+    coords: tuple[str, ...],
+    order: int | None,
+) -> None:
+    points = _parse_coords(coords)
+
+    if len(points) == 1:
+        lat, lon = points[0]
+        body: dict[str, object] = {"lat": lat, "lon": lon}
+        if order is not None:
+            body["order"] = order
+        await execute_command(
+            app_ctx,
+            vin_positional,
+            "navigation_gps_request",
+            "nav.gps",
+            body=body,
+            success_message="GPS coordinates sent to vehicle.",
+        )
+    else:
+        # Multi-point: send each with auto-incrementing order
+        start_order = order if order is not None else 1
+        for idx, (lat, lon) in enumerate(points):
+            await execute_command(
+                app_ctx,
+                vin_positional,
+                "navigation_gps_request",
+                "nav.gps",
+                body={"lat": lat, "lon": lon, "order": start_order + idx},
+                success_message=f"GPS waypoint {start_order + idx} sent to vehicle.",
+            )
+
+
+@nav_group.command("supercharger")
+@click.argument("vin_positional", required=False, default=None, metavar="VIN")
+@global_options
+def supercharger_cmd(app_ctx: AppContext, vin_positional: str | None) -> None:
+    """Navigate to the nearest Supercharger."""
+    run_async(
+        execute_command(
+            app_ctx,
+            vin_positional,
+            "navigation_sc_request",
+            "nav.supercharger",
+            success_message="Navigating to nearest Supercharger.",
+        )
+    )
+
+
+@nav_group.command("homelink")
+@click.argument("vin_positional", required=False, default=None, metavar="VIN")
+@click.option(
+    "--lat", type=float, default=None, help="Latitude (auto-detected from vehicle if omitted)"
+)
+@click.option(
+    "--lon", type=float, default=None, help="Longitude (auto-detected from vehicle if omitted)"
+)
+@global_options
+def homelink_cmd(
+    app_ctx: AppContext, vin_positional: str | None, lat: float | None, lon: float | None
+) -> None:
+    """Trigger HomeLink (garage door)."""
+    run_async(_cmd_homelink(app_ctx, vin_positional, lat, lon))
+
+
+async def _cmd_homelink(
+    app_ctx: AppContext,
+    vin_positional: str | None,
+    lat: float | None,
+    lon: float | None,
+) -> None:
+    formatter = app_ctx.formatter
+    vin = require_vin(vin_positional, app_ctx.vin)
+
+    # Auto-detect coordinates from vehicle drive_state if not provided
+    if lat is None or lon is None:
+        client, vehicle_api = get_vehicle_api(app_ctx)
+        try:
+            vdata = await cached_vehicle_data(app_ctx, vehicle_api, vin, endpoints=["drive_state"])
+        finally:
+            await client.close()
+
+        ds = vdata.drive_state
+        if ds and ds.latitude is not None and ds.longitude is not None:
+            lat = ds.latitude
+            lon = ds.longitude
+        else:
+            from tescmd.api.errors import ConfigError
+
+            raise ConfigError(
+                "Cannot detect vehicle location. Provide --lat and --lon explicitly."
+            )
+
+    client, vehicle_api, cmd_api = get_command_api(app_ctx)
+    try:
+        result = await auto_wake(
+            formatter,
+            vehicle_api,
+            vin,
+            lambda: cmd_api.trigger_homelink(vin, lat=lat, lon=lon),
+            auto=app_ctx.auto_wake,
+        )
+    finally:
+        await client.close()
+
+    invalidate_cache_for_vin(app_ctx, vin)
+
+    if formatter.format == "json":
+        formatter.output(result, command="nav.homelink")
+    else:
+        msg = result.response.reason or "HomeLink triggered."
+        formatter.rich.command_result(result.response.result, msg)
+
+
+@nav_group.command("waypoints")
+@click.argument("vin_positional", required=False, default=None, metavar="VIN")
+@click.argument("place_ids", nargs=-1, required=True)
+@global_options
+def waypoints_cmd(
+    app_ctx: AppContext, vin_positional: str | None, place_ids: tuple[str, ...]
+) -> None:
+    """Send multi-stop waypoints using Google Place IDs.
+
+    PLACE_IDS are one or more Google Maps Place IDs.  Each ID is prefixed
+    with ``refId:`` and joined into a comma-separated string before being
+    sent to the vehicle.
+
+    Example::
+
+        tescmd nav waypoints ChIJIQBpAG2ahYAR_6128GcTUEo ChIJw____96GhYARCVVwg5cT7c0
+    """
+    waypoints_str = ",".join(f"refId:{pid}" for pid in place_ids)
+    run_async(
+        execute_command(
+            app_ctx,
+            vin_positional,
+            "navigation_waypoints_request",
+            "nav.waypoints",
+            body={"waypoints": waypoints_str},
+            success_message="Waypoints sent to vehicle.",
+        )
+    )

tescmd/cli/partner.py

@@ -0,0 +1,112 @@
+"""CLI commands for partner account endpoints."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import click
+
+from tescmd._internal.async_utils import run_async
+from tescmd.cli._client import TTL_SLOW, TTL_STATIC, cached_api_call, get_partner_api
+from tescmd.cli._options import global_options
+
+if TYPE_CHECKING:
+    from tescmd.cli.main import AppContext
+
+partner_group = click.Group(
+    "partner", help="Partner account endpoints (require client credentials)"
+)
+
+
+@partner_group.command("public-key")
+@click.option("--domain", required=True, help="Domain to look up")
+@global_options
+def public_key_cmd(app_ctx: AppContext, domain: str) -> None:
+    """Get the public key registered for DOMAIN."""
+    run_async(_cmd_public_key(app_ctx, domain))
+
+
+async def _cmd_public_key(app_ctx: AppContext, domain: str) -> None:
+    formatter = app_ctx.formatter
+    client, api = await get_partner_api(app_ctx)
+    try:
+        result = await cached_api_call(
+            app_ctx,
+            scope="partner",
+            identifier=domain,
+            endpoint="partner.public-key",
+            fetch=lambda: api.public_key(domain=domain),
+            ttl=TTL_STATIC,
+        )
+    finally:
+        await client.close()
+
+    if formatter.format == "json":
+        formatter.output(result, command="partner.public-key")
+    else:
+        formatter.rich._dict_table("Public Key", result)
+
+
+@partner_group.command("telemetry-error-vins")
+@global_options
+def telemetry_error_vins_cmd(app_ctx: AppContext) -> None:
+    """List VINs with recent fleet telemetry errors."""
+    run_async(_cmd_telemetry_error_vins(app_ctx))
+
+
+async def _cmd_telemetry_error_vins(app_ctx: AppContext) -> None:
+    formatter = app_ctx.formatter
+    client, api = await get_partner_api(app_ctx)
+    try:
+        result = await cached_api_call(
+            app_ctx,
+            scope="partner",
+            identifier="global",
+            endpoint="partner.telemetry-error-vins",
+            fetch=lambda: api.fleet_telemetry_error_vins(),
+            ttl=TTL_SLOW,
+        )
+    finally:
+        await client.close()
+
+    if formatter.format == "json":
+        formatter.output(result, command="partner.telemetry-error-vins")
+    else:
+        if result:
+            formatter.rich.info("VINs with telemetry errors:")
+            for vin in result:
+                formatter.rich.info(f"  {vin}")
+        else:
+            formatter.rich.info("[dim]No VINs with telemetry errors.[/dim]")
+
+
+@partner_group.command("telemetry-errors")
+@global_options
+def telemetry_errors_cmd(app_ctx: AppContext) -> None:
+    """Get recent fleet telemetry errors across all vehicles."""
+    run_async(_cmd_telemetry_errors(app_ctx))
+
+
+async def _cmd_telemetry_errors(app_ctx: AppContext) -> None:
+    formatter = app_ctx.formatter
+    client, api = await get_partner_api(app_ctx)
+    try:
+        result = await cached_api_call(
+            app_ctx,
+            scope="partner",
+            identifier="global",
+            endpoint="partner.telemetry-errors",
+            fetch=lambda: api.fleet_telemetry_errors(),
+            ttl=TTL_SLOW,
+        )
+    finally:
+        await client.close()
+
+    if formatter.format == "json":
+        formatter.output(result, command="partner.telemetry-errors")
+    else:
+        if result:
+            for err in result:
+                formatter.rich._dict_table("Telemetry Error", err)
+        else:
+            formatter.rich.info("[dim]No recent telemetry errors.[/dim]")

tescmd/cli/raw.py

@@ -0,0 +1,75 @@
+"""CLI commands for raw Fleet API access (power-user escape hatch)."""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING
+
+import click
+
+from tescmd._internal.async_utils import run_async
+from tescmd.cli._client import get_client
+from tescmd.cli._options import global_options
+
+if TYPE_CHECKING:
+    from tescmd.cli.main import AppContext
+
+raw_group = click.Group("raw", help="Raw Fleet API access")
+
+
+@raw_group.command("get")
+@click.argument("path")
+@click.option("--params", default=None, help="Query parameters as JSON string")
+@global_options
+def get_cmd(app_ctx: AppContext, path: str, params: str | None) -> None:
+    """Send a raw GET request to PATH.
+
+    Example: tescmd raw get /api/1/vehicles
+    """
+    run_async(_cmd_get(app_ctx, path, params))
+
+
+async def _cmd_get(app_ctx: AppContext, path: str, params_json: str | None) -> None:
+    formatter = app_ctx.formatter
+    client = get_client(app_ctx)
+    try:
+        kwargs: dict[str, object] = {}
+        if params_json:
+            kwargs["params"] = json.loads(params_json)
+        data = await client.get(path, **kwargs)
+    finally:
+        await client.close()
+
+    if formatter.format == "json":
+        formatter.output(data, command="raw.get")
+    else:
+        formatter.rich.info(json.dumps(data, indent=2, default=str))
+
+
+@raw_group.command("post")
+@click.argument("path")
+@click.option("--body", default=None, help="Request body as JSON string")
+@global_options
+def post_cmd(app_ctx: AppContext, path: str, body: str | None) -> None:
+    """Send a raw POST request to PATH.
+
+    Example: tescmd raw post /api/1/vehicles/VIN/command/flash_lights
+    """
+    run_async(_cmd_post(app_ctx, path, body))
+
+
+async def _cmd_post(app_ctx: AppContext, path: str, body_json: str | None) -> None:
+    formatter = app_ctx.formatter
+    client = get_client(app_ctx)
+    try:
+        kwargs: dict[str, object] = {}
+        if body_json:
+            kwargs["json"] = json.loads(body_json)
+        data = await client.post(path, **kwargs)
+    finally:
+        await client.close()
+
+    if formatter.format == "json":
+        formatter.output(data, command="raw.post")
+    else:
+        formatter.rich.info(json.dumps(data, indent=2, default=str))