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

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,