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

tescmd/cli/setup.py

@@ -182,13 +182,22 @@ def _developer_portal_setup(
     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
+    )
 
 
 # ---------------------------------------------------------------------------
@@ -197,7 +206,7 @@ def _developer_portal_setup(
 
 
 def _domain_setup(formatter: OutputFormatter, settings: AppSettings) -> str:
-    """Set up a domain via GitHub Pages or manual entry."""
+    """Set up a domain via GitHub Pages, Tailscale Funnel, or manual entry."""
     info = formatter.rich.info
 
     if settings.domain:
@@ -207,22 +216,30 @@ def _domain_setup(formatter: OutputFormatter, settings: AppSettings) -> str:
 
     info("[bold]Phase 1: Domain Setup[/bold]")
     info("")
-    info(
-        "Tesla requires a registered domain for Fleet API access."
-        " The easiest approach is a free GitHub Pages site."
-    )
+    info("Tesla requires a registered domain for Fleet API access.")
     info("")
 
-    # Try automated GitHub Pages setup
+    # Priority 1: GitHub Pages (always-on hosting)
     from tescmd.deploy.github_pages import is_gh_authenticated, is_gh_available
 
     if is_gh_available() and is_gh_authenticated():
         return _automated_domain_setup(formatter, settings)
 
-    # Fall back to manual domain entry
+    # Priority 2: Tailscale Funnel (requires local machine running)
+    if run_async(_is_tailscale_ready()):
+        return _tailscale_domain_setup(formatter, settings)
+
+    # Priority 3: Manual
     return _manual_domain_setup(formatter)
 
 
+async def _is_tailscale_ready() -> bool:
+    """Wrapper to check Tailscale readiness without raising."""
+    from tescmd.deploy.tailscale_serve import is_tailscale_serve_ready
+
+    return await is_tailscale_serve_ready()
+
+
 def _automated_domain_setup(formatter: OutputFormatter, settings: AppSettings) -> str:
     """Offer to auto-create a GitHub Pages site."""
     info = formatter.rich.info
@@ -239,6 +256,11 @@ 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[/dim]")
+    info("[dim]serve as a Fleet Telemetry server. If you plan to use telemetry[/dim]")
+    info("[dim]streaming, choose Tailscale instead (install Tailscale, then[/dim]")
+    info("[dim]re-run setup).[/dim]")
+    info("")
 
     try:
         answer = input(f"Create/use {suggested_domain} as your domain? [Y/n] ").strip()
@@ -266,6 +288,56 @@ def _automated_domain_setup(formatter: OutputFormatter, settings: AppSettings) -
     return domain
 
 
+def _tailscale_domain_setup(formatter: OutputFormatter, settings: AppSettings) -> str:
+    """Offer to use Tailscale Funnel for key hosting."""
+    info = formatter.rich.info
+
+    from tescmd.telemetry.tailscale import TailscaleManager
+
+    hostname: str = run_async(TailscaleManager().get_hostname())
+
+    info("Tailscale detected. Your key would be hosted at:")
+    info(f"  [cyan]https://{hostname}/{_WELL_KNOWN_PATH}[/cyan]")
+    info("")
+    info("[yellow]Important:[/yellow] Tailscale Funnel requires your machine to be running.")
+    info("If your machine is off or Tailscale stops, Tesla cannot reach your")
+    info("public key. This is fine for development and testing.")
+    info("For always-on hosting, use GitHub Pages instead (install gh CLI).")
+    info("")
+    info("[green]Telemetry streaming:[/green] If you plan to use Fleet Telemetry")
+    info("streaming (tescmd vehicle telemetry stream), you should use your")
+    info("Tailscale hostname as your domain. Tesla requires the telemetry")
+    info("server hostname to match your registered domain.")
+    info("")
+
+    try:
+        answer = input(f"Use {hostname} as your domain? [Y/n] ").strip()
+    except (EOFError, KeyboardInterrupt):
+        info("")
+        return ""
+
+    if answer.lower() == "n":
+        return _manual_domain_setup(formatter)
+
+    domain = hostname
+
+    # Persist domain and hosting method to .env
+    from tescmd.cli.auth import _write_env_value
+
+    _write_env_value("TESLA_DOMAIN", domain)
+    _write_env_value("TESLA_HOSTING_METHOD", "tailscale")
+
+    info(f"[green]Domain configured: {domain}[/green]")
+    info("[green]Hosting method: Tailscale Funnel[/green]")
+    info("")
+
+    return domain
+
+
+# Well-known path constant (shared with deploy modules)
+_WELL_KNOWN_PATH = ".well-known/appspecific/com.tesla.3p.public-key.pem"
+
+
 def _manual_domain_setup(formatter: OutputFormatter) -> str:
     """Prompt for a domain manually."""
     from tescmd.cli.auth import _prompt_for_domain
@@ -279,7 +351,7 @@ def _manual_domain_setup(formatter: OutputFormatter) -> str:
 
 
 def _key_setup(formatter: OutputFormatter, settings: AppSettings, domain: str) -> None:
-    """Generate keys and deploy to GitHub Pages (full tier only)."""
+    """Generate keys and deploy via the configured hosting method (full tier only)."""
     info = formatter.rich.info
 
     info("[bold]Phase 3: EC Key Generation & Deployment[/bold]")
@@ -291,7 +363,6 @@ def _key_setup(formatter: OutputFormatter, settings: AppSettings, domain: str) -
         generate_ec_key_pair,
         get_key_fingerprint,
         has_key_pair,
-        load_public_key_pem,
     )
 
     # Generate keys if needed
@@ -305,7 +376,69 @@ def _key_setup(formatter: OutputFormatter, settings: AppSettings, domain: str) -
 
     info("")
 
-    # Deploy key via GitHub Pages if gh is available
+    # Branch on hosting method
+    hosting = settings.hosting_method
+
+    if hosting == "tailscale":
+        _deploy_key_tailscale(formatter, settings, key_dir, domain)
+    else:
+        _deploy_key_github(formatter, settings, key_dir, domain)
+
+
+def _deploy_key_tailscale(
+    formatter: OutputFormatter,
+    settings: AppSettings,
+    key_dir: Path,
+    domain: str,
+) -> None:
+    """Deploy key via Tailscale Funnel."""
+    info = formatter.rich.info
+
+    from tescmd.crypto.keys import load_public_key_pem
+    from tescmd.deploy.tailscale_serve import (
+        deploy_public_key_tailscale,
+        get_key_url,
+        start_key_serving,
+        validate_tailscale_key_url,
+        wait_for_tailscale_deployment,
+    )
+
+    # Check if key is already deployed
+    if run_async(validate_tailscale_key_url(domain)):
+        info(f"Public key: [green]already accessible[/green] at {get_key_url(domain)}")
+        info("")
+        return
+
+    info("Deploying public key via Tailscale Funnel...")
+    pem = load_public_key_pem(key_dir)
+    run_async(deploy_public_key_tailscale(pem))
+    run_async(start_key_serving())
+
+    info("[green]Tailscale serve + Funnel started.[/green]")
+    info("Waiting for key to become accessible...")
+
+    deployed = run_async(wait_for_tailscale_deployment(domain))
+    if deployed:
+        info(f"[green]Key is live at:[/green] {get_key_url(domain)}")
+    else:
+        info(
+            "[yellow]Key deployed but not yet accessible."
+            " Tailscale Funnel may still be propagating.[/yellow]"
+        )
+        info("  Run [cyan]tescmd key validate[/cyan] to check later.")
+    info("")
+
+
+def _deploy_key_github(
+    formatter: OutputFormatter,
+    settings: AppSettings,
+    key_dir: Path,
+    domain: str,
+) -> None:
+    """Deploy key via GitHub Pages."""
+    info = formatter.rich.info
+
+    from tescmd.crypto.keys import load_public_key_pem
     from tescmd.deploy.github_pages import (
         deploy_public_key,
         get_key_url,
@@ -367,7 +500,6 @@ async def _enrollment_step(
     import webbrowser
 
     from tescmd.crypto.keys import get_key_fingerprint, has_key_pair
-    from tescmd.deploy.github_pages import get_key_url, validate_key_url
 
     info = formatter.rich.info
     key_dir = Path(settings.config_dir).expanduser() / "keys"
@@ -388,9 +520,21 @@ async def _enrollment_step(
     info("  must also be enrolled via the Tesla app.")
     info("")
 
-    # Verify the public key is accessible
-    key_url = get_key_url(domain)
-    key_accessible = validate_key_url(domain)
+    # Verify the public key is accessible (method-aware)
+    if settings.hosting_method == "tailscale":
+        from tescmd.deploy.tailscale_serve import get_key_url
+        from tescmd.deploy.tailscale_serve import (
+            validate_tailscale_key_url as _validate,
+        )
+
+        key_url = get_key_url(domain)
+        key_accessible = await _validate(domain)
+    else:
+        from tescmd.deploy.github_pages import get_key_url as gh_get_key_url
+        from tescmd.deploy.github_pages import validate_key_url
+
+        key_url = gh_get_key_url(domain)
+        key_accessible = validate_key_url(domain)
     if not key_accessible:
         info(f"  [yellow]Public key not accessible at {key_url}[/yellow]")
         info("  Enrollment requires the key to be live. Skipping for now.")
@@ -509,16 +653,30 @@ def _precheck_public_key(
     """
     info = formatter.rich.info
 
-    from tescmd.deploy.github_pages import get_key_url, validate_key_url
-
     info("Checking public key availability...")
 
-    if validate_key_url(domain):
-        info(f"  Public key: [green]accessible[/green] at {get_key_url(domain)}")
+    # Check accessibility via the appropriate method
+    if settings.hosting_method == "tailscale":
+        from tescmd.deploy.tailscale_serve import (
+            get_key_url,
+            validate_tailscale_key_url,
+        )
+
+        key_url = get_key_url(domain)
+        accessible = run_async(validate_tailscale_key_url(domain))
+    else:
+        from tescmd.deploy.github_pages import get_key_url as gh_get_key_url
+        from tescmd.deploy.github_pages import validate_key_url
+
+        key_url = gh_get_key_url(domain)
+        accessible = validate_key_url(domain)
+
+    if accessible:
+        info(f"  Public key: [green]accessible[/green] at {key_url}")
         info("")
         return True
 
-    info(f"  Public key: [yellow]not found[/yellow] at {get_key_url(domain)}")
+    info(f"  Public key: [yellow]not found[/yellow] at {key_url}")
     info("")
     info("  Tesla requires your public key to be accessible before registration will succeed.")
     info("")
@@ -543,7 +701,7 @@ def _auto_deploy_key(
     settings: AppSettings,
     domain: str,
 ) -> bool:
-    """Generate a key pair (if needed), deploy to GitHub Pages, and wait.
+    """Generate a key pair (if needed), deploy via configured method, and wait.
 
     Returns True when the key is confirmed accessible, False otherwise.
     """
@@ -554,7 +712,6 @@ def _auto_deploy_key(
         generate_ec_key_pair,
         get_key_fingerprint,
         has_key_pair,
-        load_public_key_pem,
     )
 
     # 1. Generate keys if needed
@@ -566,7 +723,63 @@ def _auto_deploy_key(
         info(f"[green]Key pair generated.[/green] Fingerprint: {get_key_fingerprint(key_dir)}")
     info("")
 
-    # 2. Deploy to GitHub Pages
+    # 2. Deploy via the appropriate method
+    if settings.hosting_method == "tailscale":
+        return _auto_deploy_key_tailscale(info, key_dir, domain)
+    return _auto_deploy_key_github(info, settings, key_dir, domain)
+
+
+def _auto_deploy_key_tailscale(
+    info: _InfoFn,
+    key_dir: Path,
+    domain: str,
+) -> bool:
+    """Deploy key via Tailscale Funnel and wait."""
+    from tescmd.crypto.keys import load_public_key_pem
+    from tescmd.deploy.tailscale_serve import (
+        deploy_public_key_tailscale,
+        get_key_url,
+        start_key_serving,
+        validate_tailscale_key_url,
+        wait_for_tailscale_deployment,
+    )
+
+    # Already deployed?
+    if run_async(validate_tailscale_key_url(domain)):
+        info(f"Public key: [green]already accessible[/green] at {get_key_url(domain)}")
+        info("")
+        return True
+
+    info("Deploying public key via Tailscale Funnel...")
+    pem = load_public_key_pem(key_dir)
+    run_async(deploy_public_key_tailscale(pem))
+    run_async(start_key_serving())
+
+    info("[green]Tailscale serve + Funnel started.[/green]")
+    info("Waiting for key to become accessible...")
+
+    deployed = run_async(wait_for_tailscale_deployment(domain))
+    if deployed:
+        info(f"[green]Key is live at:[/green] {get_key_url(domain)}")
+        info("")
+        return True
+
+    info("[yellow]Key deployed but not yet accessible.[/yellow]")
+    info(
+        "  Run [cyan]tescmd key validate[/cyan] to check, then [cyan]tescmd auth register[/cyan]."
+    )
+    info("")
+    return False
+
+
+def _auto_deploy_key_github(
+    info: _InfoFn,
+    settings: AppSettings,
+    key_dir: Path,
+    domain: str,
+) -> bool:
+    """Deploy key via GitHub Pages and wait."""
+    from tescmd.crypto.keys import load_public_key_pem
     from tescmd.deploy.github_pages import (
         deploy_public_key,
         get_key_url,
@@ -632,6 +845,10 @@ def _remediate_412(info: _InfoFn, domain: str) -> None:
     info("  2. Open your application")
     info("  3. Set [cyan]Allowed Origin URL[/cyan] to:")
     info(f"     [bold]https://{domain}[/bold]")
+    info(
+        "     [dim]For telemetry streaming, also add your Tailscale origin"
+        " (e.g. https://<machine>.tailnet.ts.net)[/dim]"
+    )
     info("  4. Save, then re-run [cyan]tescmd setup[/cyan]")
 
 
@@ -716,7 +933,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]")