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

tescmd/cli/setup.py

@@ -29,10 +29,11 @@ TIER_FULL = "full"
 
 
 @click.command("setup")
+@click.option("--force", is_flag=True, help="Reconfigure everything from scratch.")
 @global_options
-def setup_cmd(app_ctx: AppContext) -> None:
+def setup_cmd(app_ctx: AppContext, force: bool) -> None:
     """Interactive setup wizard for first-time configuration."""
-    run_async(_cmd_setup(app_ctx))
+    run_async(_cmd_setup(app_ctx, force=force))
 
 
 # ---------------------------------------------------------------------------
@@ -40,29 +41,35 @@ def setup_cmd(app_ctx: AppContext) -> None:
 # ---------------------------------------------------------------------------
 
 
-async def _cmd_setup(app_ctx: AppContext) -> None:
+async def _cmd_setup(app_ctx: AppContext, *, force: bool = False) -> None:
     """Run the tiered onboarding wizard."""
     formatter = app_ctx.formatter
     settings = AppSettings()
 
     # Phase 0: Welcome + tier selection
-    tier = _prompt_tier(formatter, settings)
+    tier = _prompt_tier(formatter, settings, force=force)
     if not tier:
         return
 
     # Phase 1: Domain setup via GitHub Pages (must happen before developer
     # portal because Tesla requires the Allowed Origin URL to match the
     # registration domain)
-    domain = _domain_setup(formatter, settings)
+    domain = _domain_setup(formatter, settings, force=force)
     if not domain:
         return
 
     # Re-read settings after potential .env changes
     settings = AppSettings()
 
+    # Early check: warn if remote key differs from local
+    if tier == TIER_FULL:
+        _check_key_mismatch(formatter, settings, domain)
+
     # Phase 2: Developer portal walkthrough (credentials — uses domain for
     # the Allowed Origin URL instructions)
-    client_id, client_secret = _developer_portal_setup(formatter, app_ctx, settings, domain=domain)
+    client_id, client_secret = _developer_portal_setup(
+        formatter, app_ctx, settings, domain=domain, force=force, tier=tier
+    )
     if not client_id:
         return
 
@@ -71,17 +78,17 @@ async def _cmd_setup(app_ctx: AppContext) -> None:
 
     # Phase 3: Key generation + deployment (full tier only)
     if tier == TIER_FULL:
-        _key_setup(formatter, settings, domain)
-
-    # Phase 3.5: Key enrollment (full tier only)
-    if tier == TIER_FULL:
-        await _enrollment_step(formatter, app_ctx, settings)
+        _key_setup(formatter, settings, domain, force=force)
 
-    # Phase 4: Fleet API partner registration
+    # Phase 4: Fleet API partner registration (closes out the setup phases)
     await _registration_step(formatter, app_ctx, settings, client_id, client_secret, domain)
 
     # Phase 5: OAuth login
-    await _oauth_login_step(formatter, app_ctx, settings, client_id, client_secret)
+    await _oauth_login_step(formatter, app_ctx, settings, client_id, client_secret, force=force)
+
+    # Phase 3.5: Key enrollment (full tier only — after login)
+    if tier == TIER_FULL:
+        await _enrollment_step(formatter, app_ctx, settings)
 
     # Phase 6: Summary
     _print_next_steps(formatter, tier)
@@ -92,13 +99,13 @@ async def _cmd_setup(app_ctx: AppContext) -> None:
 # ---------------------------------------------------------------------------
 
 
-def _prompt_tier(formatter: OutputFormatter, settings: AppSettings) -> str:
+def _prompt_tier(formatter: OutputFormatter, settings: AppSettings, *, force: bool = False) -> str:
     """Ask the user which tier they want and persist the choice."""
     info = formatter.rich.info
 
     # If already configured, offer to keep or change
     existing_tier = settings.setup_tier
-    if existing_tier in (TIER_READONLY, TIER_FULL):
+    if existing_tier in (TIER_READONLY, TIER_FULL) and not force:
         info(f"Setup tier: [cyan]{existing_tier}[/cyan] (previously configured)")
         info("")
 
@@ -157,6 +164,47 @@ def _prompt_tier(formatter: OutputFormatter, settings: AppSettings) -> str:
     return tier
 
 
+# ---------------------------------------------------------------------------
+# Key mismatch warning (between Phase 1 and Phase 2)
+# ---------------------------------------------------------------------------
+
+
+def _check_key_mismatch(
+    formatter: OutputFormatter,
+    settings: AppSettings,
+    domain: str,
+) -> None:
+    """Warn early if the remote public key differs from the local key."""
+    info = formatter.rich.info
+    key_dir = Path(settings.config_dir).expanduser() / "keys"
+
+    from tescmd.crypto.keys import has_key_pair, load_public_key_pem
+
+    if not has_key_pair(key_dir):
+        return
+
+    pem = load_public_key_pem(key_dir)
+
+    # Fetch remote key (method-aware)
+    if settings.hosting_method == "tailscale":
+        from tescmd.deploy.tailscale_serve import fetch_tailscale_key_pem, get_key_url
+
+        url = get_key_url(domain)
+        remote_pem = fetch_tailscale_key_pem(domain)
+    else:
+        from tescmd.deploy.github_pages import fetch_key_pem, get_key_url
+
+        url = get_key_url(domain)
+        remote_pem = fetch_key_pem(domain)
+
+    if remote_pem is not None and remote_pem != pem.strip():
+        info("[yellow]The public key on your domain differs from your local key.[/yellow]")
+        info(f"  Remote: {url}")
+        info("  This can happen after regenerating your key pair.")
+        info("  The key will be redeployed in Phase 3.")
+        info("")
+
+
 # ---------------------------------------------------------------------------
 # Phase 2: Developer portal walkthrough
 # ---------------------------------------------------------------------------
@@ -168,6 +216,8 @@ def _developer_portal_setup(
     settings: AppSettings,
     *,
     domain: str = "",
+    force: bool = False,
+    tier: str = "",
 ) -> tuple[str, str]:
     """Walk through Tesla Developer Portal setup if credentials are missing."""
     info = formatter.rich.info
@@ -175,20 +225,35 @@ def _developer_portal_setup(
     client_id = settings.client_id
     client_secret = settings.client_secret
 
-    if client_id:
+    if client_id and not force:
         info(f"Client ID: [cyan]{client_id[:8]}...[/cyan] (already configured)")
         return (client_id, client_secret or "")
 
     info("[bold]Phase 2: Tesla Developer Portal Setup[/bold]")
     info("")
 
+    # Detect Tailscale hostname if domain was set to Tailscale in Phase 1
+    ts_hostname = ""
+    if settings.hosting_method == "tailscale" and settings.domain:
+        ts_hostname = settings.domain
+
     # Delegate to the existing interactive setup wizard, passing the domain
     # so the portal instructions show the correct Allowed Origin URL
-    port = 8085
+    from tescmd.models.auth import DEFAULT_PORT
+
+    port = DEFAULT_PORT
     redirect_uri = f"http://localhost:{port}/callback"
     from tescmd.cli.auth import _interactive_setup
 
-    return _interactive_setup(formatter, port, redirect_uri, domain=domain)
+    return _interactive_setup(
+        formatter,
+        port,
+        redirect_uri,
+        domain=domain,
+        tailscale_hostname=ts_hostname,
+        full_tier=(tier == TIER_FULL),
+        force=force,
+    )
 
 
 # ---------------------------------------------------------------------------
@@ -196,11 +261,13 @@ def _developer_portal_setup(
 # ---------------------------------------------------------------------------
 
 
-def _domain_setup(formatter: OutputFormatter, settings: AppSettings) -> str:
+def _domain_setup(
+    formatter: OutputFormatter, settings: AppSettings, *, force: bool = False
+) -> str:
     """Set up a domain via GitHub Pages, Tailscale Funnel, or manual entry."""
     info = formatter.rich.info
 
-    if settings.domain:
+    if settings.domain and not force:
         info(f"Domain: [cyan]{settings.domain}[/cyan] (already configured)")
         info("")
         return settings.domain
@@ -247,10 +314,10 @@ def _automated_domain_setup(formatter: OutputFormatter, settings: AppSettings) -
     info(f"GitHub CLI detected. Logged in as [cyan]{username}[/cyan].")
     info(f"Suggested domain: [cyan]{suggested_domain}[/cyan]")
     info("")
-    info("[dim]Note: GitHub Pages provides always-on key hosting but cannot")
-    info("serve as a Fleet Telemetry server. If you plan to use telemetry")
-    info("streaming, choose Tailscale instead (install Tailscale, then")
-    info("re-run setup).[/dim]")
+    info("[dim]Note: GitHub Pages provides always-on key hosting. For Fleet[/dim]")
+    info("[dim]Telemetry streaming, Tailscale will also be used alongside[/dim]")
+    info("[dim]GitHub Pages — just add your Tailscale hostname as an extra[/dim]")
+    info("[dim]Allowed Origin URL in the developer portal.[/dim]")
     info("")
 
     try:
@@ -341,7 +408,9 @@ def _manual_domain_setup(formatter: OutputFormatter) -> str:
 # ---------------------------------------------------------------------------
 
 
-def _key_setup(formatter: OutputFormatter, settings: AppSettings, domain: str) -> None:
+def _key_setup(
+    formatter: OutputFormatter, settings: AppSettings, domain: str, *, force: bool = False
+) -> None:
     """Generate keys and deploy via the configured hosting method (full tier only)."""
     info = formatter.rich.info
 
@@ -356,12 +425,12 @@ def _key_setup(formatter: OutputFormatter, settings: AppSettings, domain: str) -
         has_key_pair,
     )
 
-    # Generate keys if needed
-    if has_key_pair(key_dir):
+    # Generate keys if needed (force → overwrite existing keys)
+    if has_key_pair(key_dir) and not force:
         info(f"Key pair: [cyan]exists[/cyan] (fingerprint: {get_key_fingerprint(key_dir)})")
     else:
         info("Generating EC P-256 key pair...")
-        generate_ec_key_pair(key_dir)
+        generate_ec_key_pair(key_dir, overwrite=force)
         info("[green]Key pair generated.[/green]")
         info(f"  Fingerprint: {get_key_fingerprint(key_dir)}")
 
@@ -371,9 +440,9 @@ def _key_setup(formatter: OutputFormatter, settings: AppSettings, domain: str) -
     hosting = settings.hosting_method
 
     if hosting == "tailscale":
-        _deploy_key_tailscale(formatter, settings, key_dir, domain)
+        _deploy_key_tailscale(formatter, settings, key_dir, domain, force=force)
     else:
-        _deploy_key_github(formatter, settings, key_dir, domain)
+        _deploy_key_github(formatter, settings, key_dir, domain, force=force)
 
 
 def _deploy_key_tailscale(
@@ -381,6 +450,8 @@ def _deploy_key_tailscale(
     settings: AppSettings,
     key_dir: Path,
     domain: str,
+    *,
+    force: bool = False,
 ) -> None:
     """Deploy key via Tailscale Funnel."""
     info = formatter.rich.info
@@ -395,7 +466,7 @@ def _deploy_key_tailscale(
     )
 
     # Check if key is already deployed
-    if run_async(validate_tailscale_key_url(domain)):
+    if run_async(validate_tailscale_key_url(domain)) and not force:
         info(f"Public key: [green]already accessible[/green] at {get_key_url(domain)}")
         info("")
         return
@@ -425,6 +496,8 @@ def _deploy_key_github(
     settings: AppSettings,
     key_dir: Path,
     domain: str,
+    *,
+    force: bool = False,
 ) -> None:
     """Deploy key via GitHub Pages."""
     info = formatter.rich.info
@@ -432,10 +505,10 @@ def _deploy_key_github(
     from tescmd.crypto.keys import load_public_key_pem
     from tescmd.deploy.github_pages import (
         deploy_public_key,
+        fetch_key_pem,
         get_key_url,
         is_gh_authenticated,
         is_gh_available,
-        validate_key_url,
         wait_for_pages_deployment,
     )
 
@@ -452,14 +525,33 @@ def _deploy_key_github(
         info("")
         return
 
-    # Check if key is already deployed
-    if validate_key_url(domain):
-        info(f"Public key: [green]already accessible[/green] at {get_key_url(domain)}")
+    # Compare remote key to local key
+    pem = load_public_key_pem(key_dir)
+    remote_pem = fetch_key_pem(domain)
+
+    if remote_pem is not None and remote_pem == pem.strip() and not force:
+        info(f"Public key: [green]matches GitHub[/green] at {get_key_url(domain)}")
         info("")
         return
 
-    info("Deploying public key to GitHub Pages...")
-    pem = load_public_key_pem(key_dir)
+    if remote_pem is not None:
+        # Remote key exists but differs — confirm before overwriting
+        info("[yellow]The public key on GitHub differs from your local key.[/yellow]")
+        info(f"  Remote: {get_key_url(domain)}")
+        info("  This can happen after regenerating your key pair.")
+        info("")
+        try:
+            answer = input("Update GitHub with the local key? [y/N] ").strip()
+        except (EOFError, KeyboardInterrupt):
+            answer = "n"
+        if answer.lower() != "y":
+            info("[dim]Skipped — GitHub key left unchanged.[/dim]")
+            info("")
+            return
+        info("Updating public key on GitHub Pages...")
+    else:
+        info("Deploying public key to GitHub Pages...")
+
     deploy_public_key(pem, github_repo)
 
     info("[green]Key committed and pushed.[/green]")
@@ -541,34 +633,24 @@ async def _enrollment_step(
     info(f"  Public key:  [green]accessible[/green] at {key_url}")
     info("")
 
-    try:
-        answer = input("  Open enrollment URL in your browser? [Y/n] ").strip()
-    except (EOFError, KeyboardInterrupt):
-        info("")
-        return
-
-    if answer.lower() not in ("n", "no"):
-        info("")
-        info(f"  Opening [link={enroll_url}]{enroll_url}[/link]…")
-        webbrowser.open(enroll_url)
-        info("")
+    info(f"  Opening [link={enroll_url}]{enroll_url}[/link]…")
+    webbrowser.open(enroll_url)
+    info("")
 
     info("  " + "━" * 49)
     info("    [bold yellow]ACTION REQUIRED: Add virtual key in the Tesla app[/bold yellow]")
     info("")
-    info(f"    Enrollment URL: {enroll_url}")
-    info("")
-    info("    1. Open the URL above [bold]on your phone[/bold]")
+    info("    1. Scan the QR code with your phone (iOS / Android)")
     info("    2. Tap [bold]Finish Setup[/bold] on the web page")
     info("    3. The Tesla app shows an [bold]Add Virtual Key[/bold] prompt")
     info("    4. Approve it")
     info("")
-    info("    [dim]If the prompt doesn't appear, force-quit the Tesla app,[/dim]")
-    info("    [dim]go back to your browser, and tap Finish Setup again.[/dim]")
+    info(
+        "    [dim]If the prompt doesn't appear, force-quit the Tesla app,"
+        " scan the QR code again, and tap Finish Setup.[/dim]"
+    )
     info("  " + "━" * 49)
     info("")
-    info("  After approving, try: [cyan]tescmd charge status --wake[/cyan]")
-    info("")
 
 
 # ---------------------------------------------------------------------------
@@ -617,7 +699,10 @@ async def _registration_step(
             domain=domain,
             region=region,
         )
-        info("[green]Registration successful.[/green]")
+        if _result.get("already_registered"):
+            info("[green]Already registered — no action needed.[/green]")
+        else:
+            info("[green]Registration successful.[/green]")
     except Exception as exc:
         status_code = getattr(exc, "status_code", None)
         exc_text = str(exc)
@@ -886,6 +971,8 @@ async def _oauth_login_step(
     settings: AppSettings,
     client_id: str,
     client_secret: str,
+    *,
+    force: bool = False,
 ) -> None:
     """Run the OAuth2 login flow."""
     info = formatter.rich.info
@@ -899,7 +986,7 @@ async def _oauth_login_step(
         config_dir=settings.config_dir,
     )
 
-    if store.has_token:
+    if store.has_token and not force:
         # Check whether the stored scopes cover what we need.
         # A readonly→full upgrade requires vehicle_cmds + vehicle_charging_cmds
         # that the original readonly token may not have.
@@ -924,7 +1011,9 @@ async def _oauth_login_step(
         info("[bold]Phase 5: OAuth Login[/bold]")
         info("")
 
-    port = 8085
+    from tescmd.models.auth import DEFAULT_PORT as _DEFAULT_PORT
+
+    port = _DEFAULT_PORT
     redirect_uri = f"http://localhost:{port}/callback"
 
     info("Opening your browser to sign in to Tesla...")

tescmd/cli/sharing.py

@@ -15,6 +15,7 @@ from tescmd.cli._client import (
     require_vin,
 )
 from tescmd.cli._options import global_options
+from tescmd.models.sharing import ShareInvite
 
 if TYPE_CHECKING:
     from tescmd.cli.main import AppContext
@@ -172,6 +173,7 @@ async def _cmd_list_invites(app_ctx: AppContext, vin_positional: str | None) ->
             endpoint="sharing.list-invites",
             fetch=lambda: api.list_invites(vin),
             ttl=TTL_SLOW,
+            model_class=ShareInvite,
         )
     finally:
         await client.close()

tescmd/cli/status.py

@@ -36,7 +36,7 @@ def status_cmd(app_ctx: AppContext) -> None:
     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
+    has_refresh = bool(store.refresh_token)
 
     # Key info
     key_dir = Path(settings.config_dir).expanduser() / "keys"

tescmd/cli/trunk.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 import click
 
@@ -203,22 +203,13 @@ async def _cmd_window(
     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)
+            cmd_str = "vent" if vent else "close"
+            kwargs: dict[str, Any] = {"command": cmd_str}
+            if lat is not None:
+                kwargs["lat"] = lat
+            if lon is not None:
+                kwargs["lon"] = lon
+            return await cmd_api.window_control(vin, **kwargs)
 
         result = await auto_wake(
             formatter,

tescmd/cli/user.py

@@ -9,6 +9,7 @@ import click
 from tescmd._internal.async_utils import run_async
 from tescmd.cli._client import TTL_DEFAULT, TTL_STATIC, cached_api_call, get_user_api
 from tescmd.cli._options import global_options
+from tescmd.models.user import FeatureConfig, UserInfo, UserRegion, VehicleOrder
 
 if TYPE_CHECKING:
     from tescmd.cli.main import AppContext
@@ -34,6 +35,7 @@ async def _cmd_me(app_ctx: AppContext) -> None:
             endpoint="user.me",
             fetch=lambda: api.me(),
             ttl=TTL_STATIC,
+            model_class=UserInfo,
         )
     finally:
         await client.close()
@@ -62,6 +64,7 @@ async def _cmd_region(app_ctx: AppContext) -> None:
             endpoint="user.region",
             fetch=lambda: api.region(),
             ttl=TTL_STATIC,
+            model_class=UserRegion,
         )
     finally:
         await client.close()
@@ -90,6 +93,7 @@ async def _cmd_orders(app_ctx: AppContext) -> None:
             endpoint="user.orders",
             fetch=lambda: api.orders(),
             ttl=TTL_DEFAULT,
+            model_class=VehicleOrder,
         )
     finally:
         await client.close()
@@ -130,6 +134,7 @@ async def _cmd_features(app_ctx: AppContext) -> None:
             endpoint="user.features",
             fetch=lambda: api.feature_config(),
             ttl=TTL_STATIC,
+            model_class=FeatureConfig,
         )
     finally:
         await client.close()
@@ -139,7 +144,17 @@ async def _cmd_features(app_ctx: AppContext) -> None:
     else:
         dumped = data.model_dump(exclude_none=True) if hasattr(data, "model_dump") else data
         if dumped:
+            from rich.table import Table
+
+            table = Table(title="Feature Flags")
+            table.add_column("Feature", style="bold")
+            table.add_column("Value")
             for key, val in sorted(dumped.items()):
-                formatter.rich.info(f"  {key}: {val}")
+                if isinstance(val, dict):
+                    parts = [f"{k}={v}" for k, v in val.items()]
+                    table.add_row(key, ", ".join(parts))
+                else:
+                    table.add_row(key, str(val))
+            formatter.rich._con.print(table)
         else:
             formatter.rich.info("[dim]No feature flags available.[/dim]")