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

tescmd/cli/auth.py

@@ -33,7 +33,7 @@ if TYPE_CHECKING:
     from tescmd.cli.main import AppContext
     from tescmd.output.formatter import OutputFormatter
 
-DEVELOPER_PORTAL_URL = "https://developer.tesla.com"
+DEVELOPER_PORTAL_URL = "https://developer.tesla.com/dashboard"
 
 
 # ---------------------------------------------------------------------------
@@ -49,7 +49,12 @@ auth_group = click.Group("auth", help="Authentication commands")
 
 
 @auth_group.command("login")
-@click.option("--port", type=int, default=8085, help="Local callback port")
+@click.option(
+    "--port",
+    type=int,
+    default=None,
+    help="Local callback port (default: 8085 or TESCMD_OAUTH_PORT)",
+)
 @click.option(
     "--reconsent",
     is_flag=True,
@@ -57,15 +62,20 @@ auth_group = click.Group("auth", help="Authentication commands")
     help="Force Tesla to re-display the scope consent screen.",
 )
 @global_options
-def login_cmd(app_ctx: AppContext, port: int, reconsent: bool) -> None:
+def login_cmd(app_ctx: AppContext, port: int | None, reconsent: bool) -> None:
     """Log in via OAuth2 PKCE flow."""
     run_async(_cmd_login(app_ctx, port, reconsent=reconsent))
 
 
-async def _cmd_login(app_ctx: AppContext, port: int, *, reconsent: bool = False) -> None:
+async def _cmd_login(app_ctx: AppContext, port: int | None, *, reconsent: bool = False) -> None:
+    from tescmd.models.auth import DEFAULT_PORT
+
     formatter = app_ctx.formatter
     settings = AppSettings()
 
+    if port is None:
+        port = DEFAULT_PORT
+
     client_id = settings.client_id
     client_secret = settings.client_secret
 
@@ -267,11 +277,24 @@ async def _cmd_refresh(app_ctx: AppContext) -> None:
     scopes: list[str] = meta.get("scopes", DEFAULT_SCOPES)
     region: str = meta.get("region", "na")
 
-    token_data = await refresh_access_token(
-        refresh_token=rt,
-        client_id=settings.client_id,
-        client_secret=settings.client_secret,
-    )
+    from tescmd.api.errors import AuthError
+    from tescmd.cli._client import reauth_on_expired_refresh
+
+    try:
+        token_data = await refresh_access_token(
+            refresh_token=rt,
+            client_id=settings.client_id,
+            client_secret=settings.client_secret,
+        )
+    except AuthError as exc:
+        if "login_required" not in str(exc):
+            raise
+        await reauth_on_expired_refresh(store, settings)
+        if formatter.format == "json":
+            formatter.output({"status": "re-authenticated"}, command="auth.refresh")
+        else:
+            formatter.rich.info("")
+        return
 
     store.save(
         access_token=token_data.access_token,
@@ -445,12 +468,17 @@ def _interactive_setup(
     redirect_uri: str,
     *,
     domain: str = "",
+    tailscale_hostname: str = "",
 ) -> tuple[str, str]:
     """Walk the user through first-time Tesla API credential setup.
 
     When *domain* is provided (e.g. from the setup wizard), the developer
     portal instructions show ``https://{domain}`` as the Allowed Origin URL.
     Tesla's Fleet API requires the origin to match the registration domain.
+
+    When *tailscale_hostname* is provided (or auto-detected), the user is
+    offered the chance to start a Tailscale Funnel so Tesla can verify the
+    origin URL when the portal app config is saved.
     """
     info = formatter.rich.info
     origin_url = f"https://{domain}" if domain else f"http://localhost:{port}"
@@ -497,6 +525,47 @@ def _interactive_setup(
     info("  Click Next.")
     info("")
 
+    # Detect Tailscale and offer to start Funnel for origin URL verification
+    ts_hostname = tailscale_hostname
+    ts_funnel_started = False
+    if not ts_hostname:
+        try:
+            from tescmd.deploy.tailscale_serve import is_tailscale_serve_ready
+
+            if run_async(is_tailscale_serve_ready()):
+                from tescmd.telemetry.tailscale import TailscaleManager
+
+                ts_hostname = run_async(TailscaleManager().get_hostname())
+        except Exception:
+            pass
+
+    if ts_hostname:
+        ts_origin = f"https://{ts_hostname}"
+        info("")
+        info(f"[green]Tailscale detected:[/green] {ts_hostname}")
+        info("")
+        info(f"  Adding [cyan]{ts_origin}[/cyan] as an Allowed Origin URL")
+        info("  will let [cyan]tescmd serve[/cyan] stream telemetry without")
+        info("  extra portal changes later.")
+        info("")
+        try:
+            answer = input("Start Tailscale Funnel so Tesla can verify the URL? [Y/n] ").strip()
+        except (EOFError, KeyboardInterrupt):
+            answer = "n"
+
+        if answer.lower() != "n":
+            info("Starting Tailscale Funnel...")
+            try:
+                from tescmd.telemetry.tailscale import TailscaleManager as _TsMgr
+
+                run_async(_TsMgr().enable_funnel())
+                ts_funnel_started = True
+                info(f"[green]Funnel active — {ts_origin} is reachable.[/green]")
+            except Exception as exc:
+                info(f"[yellow]Could not start Funnel: {exc}[/yellow]")
+                info("[dim]You can add the origin URL manually later.[/dim]")
+                ts_hostname = ""
+
     # Step 3 — Client Details
     info("[bold]Step 3 — Client Details[/bold]")
     info(
@@ -504,14 +573,17 @@ def _interactive_setup(
         " Machine-to-Machine[/cyan]  (the default)"
     )
     info(f"  Allowed Origin URL:  [cyan]{origin_url}[/cyan]")
+    if ts_hostname:
+        info(f"  [bold]Also add:[/bold]          [cyan]https://{ts_hostname}[/cyan]")
     info(f"  Allowed Redirect URI: [cyan]{redirect_uri}[/cyan]")
     info("  Allowed Returned URL: (leave empty)")
     info("")
-    info(
-        "  [dim]For telemetry streaming, add your Tailscale hostname"
-        " as an additional origin:[/dim]"
-    )
-    info("  [dim]  https://<machine>.tailnet.ts.net[/dim]")
+    if not ts_hostname:
+        info(
+            "  [dim]For telemetry streaming, add your Tailscale hostname"
+            " as an additional origin:[/dim]"
+        )
+        info("  [dim]  https://<machine>.tailnet.ts.net[/dim]")
     info("  Click Next.")
     info("")
 
@@ -572,6 +644,16 @@ def _interactive_setup(
         _write_env_file(client_id, client_secret)
         info("[green]Credentials saved to .env[/green]")
 
+    # Clean up Tailscale Funnel if we started it during this session
+    if ts_funnel_started:
+        try:
+            from tescmd.telemetry.tailscale import TailscaleManager as _TsMgr
+
+            run_async(_TsMgr._run("tailscale", "funnel", "--bg", "off"))
+        except Exception as exc:
+            info(f"[yellow]Warning: Failed to stop Tailscale Funnel: {exc}[/yellow]")
+            info("[dim]You may need to run 'tailscale funnel --bg off' manually.[/dim]")
+
     info("")
     return (client_id, client_secret)
 

tescmd/cli/energy.py

@@ -9,6 +9,7 @@ import click
 from tescmd._internal.async_utils import run_async
 from tescmd.cli._client import TTL_SLOW, cached_api_call, get_energy_api, invalidate_cache_for_site
 from tescmd.cli._options import global_options
+from tescmd.models.energy import SiteInfo
 
 if TYPE_CHECKING:
     from tescmd.cli.main import AppContext
@@ -66,6 +67,7 @@ async def _cmd_status(app_ctx: AppContext, site_id: int) -> None:
             endpoint="energy.status",
             fetch=lambda: api.site_info(site_id),
             ttl=TTL_SLOW,
+            model_class=SiteInfo,
         )
     finally:
         await client.close()

tescmd/cli/main.py

@@ -6,6 +6,7 @@ import dataclasses
 import logging
 
 import click
+from dotenv import load_dotenv
 
 from tescmd._internal.async_utils import run_async
 from tescmd.api.errors import (
@@ -62,6 +63,13 @@ class AppContext:
         return self._formatter
 
 
+# ---------------------------------------------------------------------------
+# Load .env into os.environ before Click resolves any envvar= options.
+# This ensures TESLA_VIN, TESCMD_MCP_CLIENT_ID, etc. from .env files
+# are visible to Click's envvar resolution.
+# ---------------------------------------------------------------------------
+load_dotenv(override=False)
+
 # ---------------------------------------------------------------------------
 # Root Click group
 # ---------------------------------------------------------------------------
@@ -160,11 +168,14 @@ def _register_commands() -> None:
     from tescmd.cli.climate import climate_group
     from tescmd.cli.energy import energy_group
     from tescmd.cli.key import key_group
+    from tescmd.cli.mcp_cmd import mcp_group
     from tescmd.cli.media import media_group
     from tescmd.cli.nav import nav_group
+    from tescmd.cli.openclaw import openclaw_group
     from tescmd.cli.partner import partner_group
     from tescmd.cli.raw import raw_group
     from tescmd.cli.security import security_group
+    from tescmd.cli.serve import serve_cmd
     from tescmd.cli.setup import setup_cmd
     from tescmd.cli.sharing import sharing_group
     from tescmd.cli.software import software_group
@@ -180,11 +191,14 @@ def _register_commands() -> None:
     cli.add_command(climate_group)
     cli.add_command(energy_group)
     cli.add_command(key_group)
+    cli.add_command(mcp_group)
     cli.add_command(media_group)
     cli.add_command(nav_group)
+    cli.add_command(openclaw_group)
     cli.add_command(partner_group)
     cli.add_command(raw_group)
     cli.add_command(security_group)
+    cli.add_command(serve_cmd)
     cli.add_command(setup_cmd)
     cli.add_command(sharing_group)
     cli.add_command(status_cmd)
@@ -563,14 +577,19 @@ def _handle_session_error(
     formatter.rich.error(message)
     formatter.rich.info("")
     formatter.rich.info("Possible causes:")
-    formatter.rich.info("  - Vehicle is temporarily unreachable")
-    formatter.rich.info("  - Local key pair is corrupted")
-    formatter.rich.info("  - Key was re-generated but not re-enrolled")
+    formatter.rich.info("  - Vehicle is temporarily unreachable or asleep")
+    formatter.rich.info("  - Session expired — retry once and a fresh handshake will occur")
+    formatter.rich.info(
+        "  - Local key pair is corrupted or was re-generated without re-enrollment"
+    )
     formatter.rich.info("")
-    formatter.rich.info("Try again, or if the problem persists:")
-    formatter.rich.info("  [cyan]tescmd key generate --force[/cyan]  (regenerate key pair)")
-    formatter.rich.info("  [cyan]tescmd key deploy[/cyan]            (re-deploy public key)")
-    formatter.rich.info("  [cyan]tescmd key enroll[/cyan]            (re-enroll on vehicle)")
+    formatter.rich.info("Try:")
+    formatter.rich.info("  1. Re-run the command (sessions auto-refresh)")
+    formatter.rich.info("  2. Use [cyan]--verbose[/cyan] to see fault codes and signing details")
+    formatter.rich.info("  3. If repeated failures, re-enroll:")
+    formatter.rich.info(
+        "     [cyan]tescmd key generate --force && tescmd key deploy && tescmd key enroll[/cyan]"
+    )
 
 
 def _handle_keyring_error(
@@ -642,4 +661,4 @@ def _handle_tunnel_error(
         " [cyan]https://login.tailscale.com/admin/acls[/cyan]"
     )
     formatter.rich.info("")
-    formatter.rich.info("Install telemetry deps: [cyan]pip install tescmd[telemetry][/cyan]")
+    formatter.rich.info("Telemetry deps are included with tescmd.")

tescmd/cli/mcp_cmd.py

@@ -0,0 +1,153 @@
+"""CLI commands for the MCP (Model Context Protocol) server."""
+
+from __future__ import annotations
+
+import click
+
+from tescmd.cli._options import global_options
+
+mcp_group = click.Group("mcp", help="MCP (Model Context Protocol) server.")
+
+
+@mcp_group.command("serve")
+@click.option(
+    "--transport",
+    type=click.Choice(["stdio", "streamable-http"]),
+    default="streamable-http",
+    help="MCP transport (default: streamable-http)",
+)
+@click.option(
+    "--port",
+    type=int,
+    default=8080,
+    envvar="TESCMD_MCP_PORT",
+    help="HTTP port (streamable-http only)",
+)
+@click.option(
+    "--host",
+    default="127.0.0.1",
+    envvar="TESCMD_HOST",
+    help="Bind address (default: 127.0.0.1)",
+)
+@click.option("--tailscale", is_flag=True, default=False, help="Expose via Tailscale Funnel")
+@click.option(
+    "--client-id",
+    envvar="TESCMD_MCP_CLIENT_ID",
+    default=None,
+    help="MCP client ID (env: TESCMD_MCP_CLIENT_ID)",
+)
+@click.option(
+    "--client-secret",
+    envvar="TESCMD_MCP_CLIENT_SECRET",
+    default=None,
+    help="MCP client secret / bearer token (env: TESCMD_MCP_CLIENT_SECRET)",
+)
+@global_options
+def serve_cmd(
+    app_ctx: object,
+    transport: str,
+    port: int,
+    host: str,
+    tailscale: bool,
+    client_id: str | None,
+    client_secret: str | None,
+) -> None:
+    """Start an MCP server exposing tescmd commands as tools.
+
+    Agents (Claude Desktop, Claude Code, etc.) connect to this server
+    and invoke tescmd commands as MCP tools with JSON output.
+
+    \b
+    Transports:
+      streamable-http  HTTP server on --port (default)
+      stdio            Read/write JSON-RPC on stdin/stdout
+
+    \b
+    Authentication (required for all transports):
+      Set TESCMD_MCP_CLIENT_ID and TESCMD_MCP_CLIENT_SECRET, or pass
+      --client-id / --client-secret. HTTP clients authenticate with
+      Authorization: Bearer <client-secret>.
+
+    \b
+    Examples:
+      tescmd mcp serve                          # HTTP on :8080
+      tescmd mcp serve --transport stdio        # stdio for Claude Desktop
+      tescmd mcp serve --tailscale              # expose via Tailscale Funnel
+    """
+    from tescmd._internal.async_utils import run_async
+    from tescmd.cli.main import AppContext
+
+    assert isinstance(app_ctx, AppContext)
+
+    if not client_id or not client_secret:
+        raise click.UsageError(
+            "MCP client credentials required.\n"
+            "Set TESCMD_MCP_CLIENT_ID and TESCMD_MCP_CLIENT_SECRET "
+            "in your .env file or environment, or pass --client-id and --client-secret."
+        )
+
+    if tailscale and transport == "stdio":
+        raise click.UsageError("--tailscale cannot be used with --transport stdio")
+
+    run_async(_cmd_serve(app_ctx, transport, port, host, tailscale, client_id, client_secret))
+
+
+async def _cmd_serve(
+    app_ctx: object,
+    transport: str,
+    port: int,
+    host: str,
+    tailscale: bool,
+    client_id: str,
+    client_secret: str,
+) -> None:
+    import sys
+
+    from tescmd.cli.main import AppContext
+    from tescmd.mcp.server import create_mcp_server
+
+    assert isinstance(app_ctx, AppContext)
+    formatter = app_ctx.formatter
+    server = create_mcp_server(client_id=client_id, client_secret=client_secret)
+    tool_count = len(server.list_tools())
+
+    if transport == "stdio":
+        # Log to stderr so stdout stays clean for JSON-RPC
+        print(f"tescmd MCP server starting (stdio, {tool_count} tools)", file=sys.stderr)
+        await server.run_stdio()
+        return
+
+    if not tailscale:
+        if formatter.format != "json":
+            formatter.rich.info(
+                f"MCP server starting on http://{host}:{port}/mcp ({tool_count} tools)"
+            )
+            formatter.rich.info("Press Ctrl+C to stop.")
+        await server.run_http(host=host, port=port)
+        return
+
+    # Tailscale Funnel mode
+    from tescmd.telemetry.tailscale import TailscaleManager
+
+    ts = TailscaleManager()
+    await ts.check_available()
+    await ts.check_running()
+
+    if formatter.format != "json":
+        formatter.rich.info(f"MCP server starting on port {port} ({tool_count} tools)")
+
+    url = await ts.start_funnel(port)
+    public_url = f"{url}/mcp"
+
+    if formatter.format != "json":
+        formatter.rich.info(f"Tailscale Funnel active: {public_url}")
+        formatter.rich.info("Press Ctrl+C to stop.")
+    else:
+        print(f'{{"url": "{public_url}"}}', file=sys.stderr)
+
+    try:
+        await server.run_http(host=host, port=port, public_url=url)
+    finally:
+        await ts.stop_funnel()
+        if formatter.format != "json":
+            formatter.rich.info("Tailscale Funnel stopped.")

tescmd/cli/nav.py

@@ -176,7 +176,9 @@ async def _cmd_homelink(
     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"])
+            vdata = await cached_vehicle_data(
+                app_ctx, vehicle_api, vin, endpoints=["location_data"]
+            )
         finally:
             await client.close()
 

tescmd/cli/openclaw.py

@@ -0,0 +1,169 @@
+"""CLI commands for OpenClaw integration."""
+
+from __future__ import annotations
+
+import logging
+import random
+
+import click
+
+from tescmd._internal.async_utils import run_async
+from tescmd.cli._client import require_vin
+from tescmd.cli._options import global_options
+
+logger = logging.getLogger(__name__)
+
+openclaw_group = click.Group("openclaw", help="OpenClaw integration commands.")
+
+
+@openclaw_group.command("bridge")
+@click.argument("vin_positional", required=False, default=None, metavar="VIN")
+@click.option(
+    "--gateway", default=None, help="Gateway WebSocket URL (default: ws://127.0.0.1:18789)"
+)
+@click.option(
+    "--token",
+    default=None,
+    envvar="OPENCLAW_GATEWAY_TOKEN",
+    help="Gateway auth token (env: OPENCLAW_GATEWAY_TOKEN)",
+)
+@click.option("--config", "config_path", default=None, help="Bridge config JSON path")
+@click.option(
+    "--port", type=int, default=None, help="Local telemetry server port (random if omitted)"
+)
+@click.option("--fields", default="default", help="Field preset or comma-separated names")
+@click.option(
+    "--interval", type=int, default=None, help="Override telemetry interval for all fields"
+)
+@click.option("--dry-run", is_flag=True, default=False, help="Log events as JSONL without sending")
+@global_options
+def bridge_cmd(
+    app_ctx: object,
+    vin_positional: str | None,
+    gateway: str | None,
+    token: str | None,
+    config_path: str | None,
+    port: int | None,
+    fields: str,
+    interval: int | None,
+    dry_run: bool,
+) -> None:
+    """Stream Fleet Telemetry to an OpenClaw Gateway.
+
+    Starts a local WebSocket server, exposes it via Tailscale Funnel,
+    configures the vehicle to push telemetry, and bridges events to
+    an OpenClaw Gateway with delta+throttle filtering.
+
+    Requires Tailscale with Funnel enabled.
+
+    \b
+    Examples:
+      tescmd openclaw bridge 5YJ3...         # default gateway (localhost:18789)
+      tescmd openclaw bridge --dry-run       # log events without sending
+      tescmd openclaw bridge --gateway ws://gw.example.com:18789
+    """
+    from tescmd.cli.main import AppContext
+
+    assert isinstance(app_ctx, AppContext)
+    run_async(
+        _cmd_bridge(
+            app_ctx,
+            vin_positional,
+            gateway,
+            token,
+            config_path,
+            port,
+            fields,
+            interval,
+            dry_run,
+        )
+    )
+
+
+async def _cmd_bridge(
+    app_ctx: object,
+    vin_positional: str | None,
+    gateway_url: str | None,
+    gateway_token: str | None,
+    config_path: str | None,
+    port: int | None,
+    fields_spec: str,
+    interval_override: int | None,
+    dry_run: bool,
+) -> None:
+    from tescmd.cli.main import AppContext
+    from tescmd.openclaw.bridge import build_openclaw_pipeline
+    from tescmd.openclaw.config import BridgeConfig
+    from tescmd.telemetry.fields import resolve_fields
+    from tescmd.telemetry.setup import telemetry_session
+
+    assert isinstance(app_ctx, AppContext)
+    formatter = app_ctx.formatter
+    vin = require_vin(vin_positional, app_ctx.vin)
+
+    if port is None:
+        port = random.randint(49152, 65534)
+
+    field_config = resolve_fields(fields_spec, interval_override)
+
+    # Load bridge config
+    config = BridgeConfig.load(config_path)
+    config = config.merge_overrides(
+        gateway_url=gateway_url,
+        gateway_token=gateway_token,
+    )
+
+    # Build pipeline via shared factory
+    from tescmd.triggers.manager import TriggerManager
+
+    trigger_manager = TriggerManager(vin=vin)
+    pipeline = build_openclaw_pipeline(
+        config, vin, app_ctx, trigger_manager=trigger_manager, dry_run=dry_run
+    )
+    gw = pipeline.gateway
+    bridge = pipeline.bridge
+
+    # Build fanout with the OpenClaw bridge as the primary sink
+    from tescmd.telemetry.fanout import FrameFanout
+
+    fanout = FrameFanout()
+    fanout.add_sink(bridge.on_frame)
+
+    # Register trigger push callback — sends notifications to gateway
+    push_cb = bridge.make_trigger_push_callback()
+    if push_cb is not None:
+        trigger_manager.add_on_fire(push_cb)
+
+    # Connect to gateway (unless dry-run)
+    if not dry_run:
+        if formatter.format != "json":
+            formatter.rich.info(f"Connecting to OpenClaw Gateway: {config.gateway_url}")
+        await gw.connect_with_backoff(max_attempts=5)
+        if formatter.format != "json":
+            formatter.rich.info("[green]Connected to gateway.[/green]")
+    else:
+        if formatter.format != "json":
+            formatter.rich.info("[yellow]Dry-run mode — events will be logged as JSONL.[/yellow]")
+
+    try:
+        async with telemetry_session(
+            app_ctx, vin, port, field_config, fanout.on_frame, interactive=False
+        ):
+            if formatter.format != "json":
+                formatter.rich.info(f"Bridge running: telemetry → {config.gateway_url}")
+
+            if formatter.format != "json":
+                formatter.rich.info("Press Ctrl+C to stop.")
+                formatter.rich.info("")
+
+            from tescmd.cli.serve import _wait_for_interrupt
+
+            await _wait_for_interrupt()
+
+            if formatter.format != "json":
+                formatter.rich.info(
+                    f"\n[dim]Events sent: {bridge.event_count}, dropped: {bridge.drop_count}[/dim]"
+                )
+    finally:
+        await bridge.send_disconnecting()
+        await gw.close()

tescmd/cli/security.py

@@ -133,7 +133,13 @@ def valet_reset_cmd(app_ctx: AppContext, vin_positional: str | None) -> None:
 @click.argument("vin_positional", required=False, default=None, metavar="VIN")
 @global_options
 def remote_start_cmd(app_ctx: AppContext, vin_positional: str | None) -> None:
-    """Enable remote start."""
+    """Enable keyless driving for 2 minutes.
+
+    \b
+    Allows starting the vehicle without a key card or phone key present.
+    The driver must press the brake pedal and shift into gear within 2
+    minutes or keyless driving is disabled again.
+    """
     run_async(
         execute_command(
             app_ctx,