tescmd 0.1.2__py3-none-any.whl

tescmd/cli/sharing.py

@@ -0,0 +1,188 @@
+"""CLI commands for vehicle sharing (drivers and invites)."""
+
+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,
+    cached_api_call,
+    get_sharing_api,
+    invalidate_cache_for_vin,
+    require_vin,
+)
+from tescmd.cli._options import global_options
+
+if TYPE_CHECKING:
+    from tescmd.cli.main import AppContext
+
+sharing_group = click.Group("sharing", help="Vehicle sharing commands")
+
+
+@sharing_group.command("add-driver")
+@click.argument("vin_positional", required=False, default=None, metavar="VIN")
+@click.argument("email")
+@global_options
+def add_driver_cmd(app_ctx: AppContext, vin_positional: str | None, email: str) -> None:
+    """Add a driver by EMAIL."""
+    run_async(_cmd_add_driver(app_ctx, vin_positional, email))
+
+
+async def _cmd_add_driver(app_ctx: AppContext, vin_positional: str | None, email: str) -> None:
+    formatter = app_ctx.formatter
+    vin = require_vin(vin_positional, app_ctx.vin)
+    client, api = get_sharing_api(app_ctx)
+    try:
+        result = await api.add_driver(vin, email=email)
+    finally:
+        await client.close()
+
+    invalidate_cache_for_vin(app_ctx, vin)
+
+    if formatter.format == "json":
+        formatter.output(result, command="sharing.add-driver")
+    else:
+        formatter.rich.info(f"Driver invite sent to {email}")
+
+
+@sharing_group.command("remove-driver")
+@click.argument("vin_positional", required=False, default=None, metavar="VIN")
+@click.argument("share_user_id", type=int)
+@global_options
+def remove_driver_cmd(app_ctx: AppContext, vin_positional: str | None, share_user_id: int) -> None:
+    """Remove a driver by SHARE_USER_ID."""
+    run_async(_cmd_remove_driver(app_ctx, vin_positional, share_user_id))
+
+
+async def _cmd_remove_driver(
+    app_ctx: AppContext, vin_positional: str | None, share_user_id: int
+) -> None:
+    formatter = app_ctx.formatter
+    vin = require_vin(vin_positional, app_ctx.vin)
+    client, api = get_sharing_api(app_ctx)
+    try:
+        result = await api.remove_driver(vin, share_user_id=share_user_id)
+    finally:
+        await client.close()
+
+    invalidate_cache_for_vin(app_ctx, vin)
+
+    if formatter.format == "json":
+        formatter.output(result, command="sharing.remove-driver")
+    else:
+        formatter.rich.info("Driver removed")
+
+
+@sharing_group.command("create-invite")
+@click.argument("vin_positional", required=False, default=None, metavar="VIN")
+@global_options
+def create_invite_cmd(app_ctx: AppContext, vin_positional: str | None) -> None:
+    """Create a vehicle share invite."""
+    run_async(_cmd_create_invite(app_ctx, vin_positional))
+
+
+async def _cmd_create_invite(app_ctx: AppContext, vin_positional: str | None) -> None:
+    formatter = app_ctx.formatter
+    vin = require_vin(vin_positional, app_ctx.vin)
+    client, api = get_sharing_api(app_ctx)
+    try:
+        result = await api.create_invite(vin)
+    finally:
+        await client.close()
+
+    invalidate_cache_for_vin(app_ctx, vin)
+
+    if formatter.format == "json":
+        formatter.output(result, command="sharing.create-invite")
+    else:
+        code = result.code or ""
+        formatter.rich.info(f"Invite created: {code}" if code else "Invite created")
+
+
+@sharing_group.command("redeem-invite")
+@click.argument("code")
+@global_options
+def redeem_invite_cmd(app_ctx: AppContext, code: str) -> None:
+    """Redeem a vehicle share invite CODE (no VIN required)."""
+    run_async(_cmd_redeem_invite(app_ctx, code))
+
+
+async def _cmd_redeem_invite(app_ctx: AppContext, code: str) -> None:
+    formatter = app_ctx.formatter
+    client, api = get_sharing_api(app_ctx)
+    try:
+        result = await api.redeem_invite(code=code)
+    finally:
+        await client.close()
+
+    if formatter.format == "json":
+        formatter.output(result, command="sharing.redeem-invite")
+    else:
+        formatter.rich.info("Invite redeemed")
+
+
+@sharing_group.command("revoke-invite")
+@click.argument("vin_positional", required=False, default=None, metavar="VIN")
+@click.argument("invite_id")
+@global_options
+def revoke_invite_cmd(app_ctx: AppContext, vin_positional: str | None, invite_id: str) -> None:
+    """Revoke a vehicle share invite by ID."""
+    run_async(_cmd_revoke_invite(app_ctx, vin_positional, invite_id))
+
+
+async def _cmd_revoke_invite(
+    app_ctx: AppContext, vin_positional: str | None, invite_id: str
+) -> None:
+    formatter = app_ctx.formatter
+    vin = require_vin(vin_positional, app_ctx.vin)
+    client, api = get_sharing_api(app_ctx)
+    try:
+        result = await api.revoke_invite(vin, invite_id=invite_id)
+    finally:
+        await client.close()
+
+    invalidate_cache_for_vin(app_ctx, vin)
+
+    if formatter.format == "json":
+        formatter.output(result, command="sharing.revoke-invite")
+    else:
+        formatter.rich.info("Invite revoked")
+
+
+@sharing_group.command("list-invites")
+@click.argument("vin_positional", required=False, default=None, metavar="VIN")
+@global_options
+def list_invites_cmd(app_ctx: AppContext, vin_positional: str | None) -> None:
+    """List active vehicle share invites."""
+    run_async(_cmd_list_invites(app_ctx, vin_positional))
+
+
+async def _cmd_list_invites(app_ctx: AppContext, vin_positional: str | None) -> None:
+    formatter = app_ctx.formatter
+    vin = require_vin(vin_positional, app_ctx.vin)
+    client, api = get_sharing_api(app_ctx)
+    try:
+        invites = await cached_api_call(
+            app_ctx,
+            scope="vin",
+            identifier=vin,
+            endpoint="sharing.list-invites",
+            fetch=lambda: api.list_invites(vin),
+            ttl=TTL_SLOW,
+        )
+    finally:
+        await client.close()
+
+    if formatter.format == "json":
+        formatter.output(invites, command="sharing.list-invites")
+    else:
+        if invites:
+            for inv in invites:
+                inv_id = (inv.get("id") if isinstance(inv, dict) else inv.id) or ""
+                inv_code = (inv.get("code") if isinstance(inv, dict) else inv.code) or ""
+                formatter.rich.info(f"  ID: {inv_id}  Code: {inv_code}")
+        else:
+            formatter.rich.info("[dim]No active invites.[/dim]")

tescmd/cli/software.py

@@ -0,0 +1,81 @@
+"""CLI commands for software update management."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import click
+
+from tescmd._internal.async_utils import run_async
+from tescmd.cli._client import cached_vehicle_data, execute_command, get_vehicle_api, require_vin
+from tescmd.cli._options import global_options
+
+if TYPE_CHECKING:
+    from tescmd.cli.main import AppContext
+
+software_group = click.Group("software", help="Software update commands")
+
+
+@software_group.command("status")
+@click.argument("vin_positional", required=False, default=None, metavar="VIN")
+@global_options
+def status_cmd(app_ctx: AppContext, vin_positional: str | None) -> None:
+    """Show current software version and update status."""
+    run_async(_cmd_status(app_ctx, vin_positional))
+
+
+async def _cmd_status(app_ctx: AppContext, vin_positional: str | None) -> None:
+    formatter = app_ctx.formatter
+    vin = require_vin(vin_positional, app_ctx.vin)
+    client, api = get_vehicle_api(app_ctx)
+    try:
+        vdata = await cached_vehicle_data(app_ctx, api, vin, endpoints=["vehicle_state"])
+    finally:
+        await client.close()
+
+    if formatter.format == "json":
+        vs = vdata.vehicle_state
+        data: dict[str, Any] = {}
+        if vs:
+            data["car_version"] = vs.car_version
+            data["software_update"] = vs.software_update
+        formatter.output(data, command="software.status")
+    else:
+        if vdata.vehicle_state:
+            formatter.rich.software_status(vdata.vehicle_state)
+        else:
+            formatter.rich.info("No vehicle state data available.")
+
+
+@software_group.command("schedule")
+@click.argument("vin_positional", required=False, default=None, metavar="VIN")
+@click.argument("seconds", type=int)
+@global_options
+def schedule_cmd(app_ctx: AppContext, vin_positional: str | None, seconds: int) -> None:
+    """Schedule a software update to install in SECONDS from now."""
+    run_async(
+        execute_command(
+            app_ctx,
+            vin_positional,
+            "schedule_software_update",
+            "software.schedule",
+            body={"offset_sec": seconds},
+            success_message=f"Software update scheduled in {seconds}s.",
+        )
+    )
+
+
+@software_group.command("cancel")
+@click.argument("vin_positional", required=False, default=None, metavar="VIN")
+@global_options
+def cancel_cmd(app_ctx: AppContext, vin_positional: str | None) -> None:
+    """Cancel a pending software update."""
+    run_async(
+        execute_command(
+            app_ctx,
+            vin_positional,
+            "cancel_software_update",
+            "software.cancel",
+            success_message="Software update cancelled.",
+        )
+    )

tescmd/cli/status.py

@@ -0,0 +1,106 @@
+"""CLI command for showing current configuration status."""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import click
+
+from tescmd.auth.token_store import TokenStore
+from tescmd.cli._client import get_cache
+from tescmd.cli._options import global_options
+from tescmd.models.config import AppSettings
+
+if TYPE_CHECKING:
+    from tescmd.cli.main import AppContext
+
+
+@click.command("status")
+@global_options
+def status_cmd(app_ctx: AppContext) -> None:
+    """Show current configuration, authentication, and cache status."""
+    formatter = app_ctx.formatter
+    settings = AppSettings()
+    store = TokenStore(
+        profile=app_ctx.profile,
+        token_file=settings.token_file,
+        config_dir=settings.config_dir,
+    )
+    cache = get_cache(app_ctx)
+    cache_info = cache.status()
+
+    # Auth info
+    has_token = store.has_token
+    meta = store.metadata or {}
+    expires_at = meta.get("expires_at", 0.0)
+    expires_in = max(0, int(expires_at - time.time())) if has_token else 0
+    has_refresh = store.refresh_token is not None
+
+    # Key info
+    key_dir = Path(settings.config_dir).expanduser() / "keys"
+    key_count = len(list(key_dir.glob("*.pem"))) // 2 if key_dir.is_dir() else 0
+
+    # Mask client ID
+    cid = settings.client_id
+    client_id_display = (cid[:8] + "\u2026") if cid and len(cid) > 8 else (cid or "not set")
+
+    data = {
+        "profile": app_ctx.profile,
+        "region": settings.region,
+        "vin": settings.vin,
+        "setup_tier": settings.setup_tier,
+        "domain": settings.domain,
+        "client_id": client_id_display,
+        "authenticated": has_token,
+        "expires_in": expires_in if has_token else None,
+        "has_refresh_token": has_refresh,
+        "cache_enabled": cache_info["enabled"],
+        "cache_ttl": cache_info["default_ttl"],
+        "cache_entries": cache_info["total"],
+        "cache_fresh": cache_info["fresh"],
+        "cache_stale": cache_info["stale"],
+        "config_dir": settings.config_dir,
+        "cache_dir": settings.cache_dir,
+        "key_pairs": key_count,
+        "token_backend": store.backend_name,
+    }
+
+    if formatter.format == "json":
+        formatter.output(data, command="status")
+    else:
+        # Profile & API
+        formatter.rich.info(f"Profile:     {data['profile']}")
+        formatter.rich.info(f"Region:      {data['region']}")
+        formatter.rich.info(f"VIN:         {data['vin'] or '[dim]not set[/dim]'}")
+        formatter.rich.info(f"Setup tier:  {data['setup_tier'] or '[dim]not set[/dim]'}")
+        formatter.rich.info(f"Domain:      {data['domain'] or '[dim]not set[/dim]'}")
+        formatter.rich.info(f"Client ID:   {data['client_id']}")
+        formatter.rich.info("")
+
+        # Auth
+        formatter.rich.info(f"Token store: {data['token_backend']}")
+        auth_str = "[green]authenticated[/green]" if has_token else "[red]not authenticated[/red]"
+        formatter.rich.info(f"Auth:        {auth_str}")
+        if has_token:
+            formatter.rich.info(f"Expires in:  {expires_in}s")
+            refresh_str = "[green]yes[/green]" if has_refresh else "[yellow]no[/yellow]"
+            formatter.rich.info(f"Refresh:     {refresh_str}")
+        formatter.rich.info("")
+
+        # Cache
+        cache_str = "[green]enabled[/green]" if data["cache_enabled"] else "[red]disabled[/red]"
+        formatter.rich.info(f"Cache:       {cache_str}")
+        formatter.rich.info(f"TTL:         {data['cache_ttl']}s")
+        formatter.rich.info(
+            f"Entries:     {data['cache_entries']}"
+            f" ({data['cache_fresh']} fresh, {data['cache_stale']} stale)"
+        )
+        formatter.rich.info("")
+
+        # Paths
+        formatter.rich.info(f"Config dir:  {data['config_dir']}")
+        formatter.rich.info(f"Cache dir:   {data['cache_dir']}")
+        key_str = f"{key_dir} ({key_count} key pair{'s' if key_count != 1 else ''})"
+        formatter.rich.info(f"Keys:        {key_str}")

tescmd/cli/trunk.py

@@ -0,0 +1,240 @@
+"""CLI commands for trunk and window operations."""
+
+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,
+    execute_command,
+    get_command_api,
+    invalidate_cache_for_vin,
+    require_vin,
+)
+from tescmd.cli._options import global_options
+
+if TYPE_CHECKING:
+    from tescmd.cli.main import AppContext
+    from tescmd.models.command import CommandResponse
+
+trunk_group = click.Group("trunk", help="Trunk and window commands")
+
+
+# ---------------------------------------------------------------------------
+# Trunk commands
+# ---------------------------------------------------------------------------
+
+
+@trunk_group.command("open")
+@click.argument("vin_positional", required=False, default=None, metavar="VIN")
+@global_options
+def open_cmd(app_ctx: AppContext, vin_positional: str | None) -> None:
+    """Open (toggle) the rear trunk."""
+    run_async(
+        execute_command(
+            app_ctx,
+            vin_positional,
+            "actuate_trunk",
+            "trunk.open",
+            body={"which_trunk": "rear"},
+            success_message="Rear trunk opened.",
+        )
+    )
+
+
+@trunk_group.command("close")
+@click.argument("vin_positional", required=False, default=None, metavar="VIN")
+@global_options
+def close_cmd(app_ctx: AppContext, vin_positional: str | None) -> None:
+    """Close (toggle) the rear trunk.
+
+    Note: actuate_trunk is a toggle — open and close both call the same endpoint.
+    """
+    run_async(
+        execute_command(
+            app_ctx,
+            vin_positional,
+            "actuate_trunk",
+            "trunk.close",
+            body={"which_trunk": "rear"},
+            success_message="Rear trunk closed.",
+        )
+    )
+
+
+@trunk_group.command("frunk")
+@click.argument("vin_positional", required=False, default=None, metavar="VIN")
+@global_options
+def frunk_cmd(app_ctx: AppContext, vin_positional: str | None) -> None:
+    """Open the front trunk (frunk)."""
+    run_async(
+        execute_command(
+            app_ctx,
+            vin_positional,
+            "actuate_trunk",
+            "trunk.frunk",
+            body={"which_trunk": "front"},
+            success_message="Frunk opened.",
+        )
+    )
+
+
+# ---------------------------------------------------------------------------
+# Sunroof command
+# ---------------------------------------------------------------------------
+
+
+@trunk_group.command("sunroof")
+@click.argument("vin_positional", required=False, default=None, metavar="VIN")
+@click.option(
+    "--state",
+    type=click.Choice(["vent", "close", "stop"]),
+    required=True,
+    help="Sunroof action: vent, close, or stop",
+)
+@global_options
+def sunroof_cmd(app_ctx: AppContext, vin_positional: str | None, state: str) -> None:
+    """Control the panoramic sunroof (vent, close, or stop)."""
+    messages = {"vent": "Sunroof vented.", "close": "Sunroof closed.", "stop": "Sunroof stopped."}
+    run_async(
+        execute_command(
+            app_ctx,
+            vin_positional,
+            "sun_roof_control",
+            "trunk.sunroof",
+            body={"state": state},
+            success_message=messages[state],
+        )
+    )
+
+
+# ---------------------------------------------------------------------------
+# Tonneau cover commands (Cybertruck)
+# ---------------------------------------------------------------------------
+
+
+@trunk_group.command("tonneau-open")
+@click.argument("vin_positional", required=False, default=None, metavar="VIN")
+@global_options
+def tonneau_open_cmd(app_ctx: AppContext, vin_positional: str | None) -> None:
+    """Open the Cybertruck tonneau cover."""
+    run_async(
+        execute_command(
+            app_ctx,
+            vin_positional,
+            "open_tonneau",
+            "trunk.tonneau-open",
+            success_message="Tonneau cover opening.",
+        )
+    )
+
+
+@trunk_group.command("tonneau-close")
+@click.argument("vin_positional", required=False, default=None, metavar="VIN")
+@global_options
+def tonneau_close_cmd(app_ctx: AppContext, vin_positional: str | None) -> None:
+    """Close the Cybertruck tonneau cover."""
+    run_async(
+        execute_command(
+            app_ctx,
+            vin_positional,
+            "close_tonneau",
+            "trunk.tonneau-close",
+            success_message="Tonneau cover closing.",
+        )
+    )
+
+
+@trunk_group.command("tonneau-stop")
+@click.argument("vin_positional", required=False, default=None, metavar="VIN")
+@global_options
+def tonneau_stop_cmd(app_ctx: AppContext, vin_positional: str | None) -> None:
+    """Stop the Cybertruck tonneau cover movement."""
+    run_async(
+        execute_command(
+            app_ctx,
+            vin_positional,
+            "stop_tonneau",
+            "trunk.tonneau-stop",
+            success_message="Tonneau cover stopped.",
+        )
+    )
+
+
+# ---------------------------------------------------------------------------
+# Window command
+# ---------------------------------------------------------------------------
+
+
+@trunk_group.command("window")
+@click.argument("vin_positional", required=False, default=None, metavar="VIN")
+@click.option("--vent/--close", "vent", default=True, help="Vent or close windows")
+@click.option("--lat", type=float, default=None, help="Vehicle latitude (for close)")
+@click.option("--lon", type=float, default=None, help="Vehicle longitude (for close)")
+@global_options
+def window_cmd(
+    app_ctx: AppContext,
+    vin_positional: str | None,
+    vent: bool,
+    lat: float | None,
+    lon: float | None,
+) -> None:
+    """Vent or close all windows.
+
+    Closing windows requires vehicle coordinates. If --lat/--lon are not
+    provided, the vehicle's current location will be fetched automatically.
+    """
+    run_async(_cmd_window(app_ctx, vin_positional, vent, lat, lon))
+
+
+async def _cmd_window(
+    app_ctx: AppContext,
+    vin_positional: str | None,
+    vent: bool,
+    lat: float | None,
+    lon: float | None,
+) -> None:
+    formatter = app_ctx.formatter
+    vin = require_vin(vin_positional, app_ctx.vin)
+    client, vehicle_api, cmd_api = get_command_api(app_ctx)
+    try:
+
+        async def _execute_window() -> CommandResponse:
+            if vent:
+                cmd_str = "vent"
+                use_lat = lat if lat is not None else 0.0
+                use_lon = lon if lon is not None else 0.0
+            else:
+                cmd_str = "close"
+                if lat is not None and lon is not None:
+                    use_lat, use_lon = lat, lon
+                else:
+                    vdata = await vehicle_api.get_vehicle_data(vin, endpoints=["drive_state"])
+                    ds = vdata.drive_state
+                    if ds and ds.latitude is not None and ds.longitude is not None:
+                        use_lat, use_lon = ds.latitude, ds.longitude
+                    else:
+                        use_lat, use_lon = 0.0, 0.0
+            return await cmd_api.window_control(vin, command=cmd_str, lat=use_lat, lon=use_lon)
+
+        result = await auto_wake(
+            formatter,
+            vehicle_api,
+            vin,
+            _execute_window,
+            auto=app_ctx.auto_wake,
+        )
+    finally:
+        await client.close()
+
+    invalidate_cache_for_vin(app_ctx, vin)
+
+    if formatter.format == "json":
+        formatter.output(result, command="trunk.window")
+    else:
+        action = "vented" if vent else "closed"
+        msg = result.response.reason or f"Windows {action}."
+        formatter.rich.command_result(result.response.result, msg)