mirror of
https://github.com/hanzoskill/tesla-fleet-api.git
synced 2026-10-30 21:08:47 +00:00
373 lines
12 KiB
Python
373 lines
12 KiB
Python
#!/usr/bin/env python3
|
|
"""Tesla Fleet API authentication and configuration.
|
|
|
|
State layout (default dir: ~/.bot/tesla-fleet-api):
|
|
- .env provider creds / overrides (TESLA_CLIENT_ID, TESLA_CLIENT_SECRET, ...)
|
|
- config.json non-token configuration
|
|
- auth.json OAuth tokens
|
|
|
|
Usage:
|
|
auth.py config
|
|
auth.py config set --audience ... --redirect-uri ...
|
|
auth.py login
|
|
auth.py refresh
|
|
auth.py register --domain example.com
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import json
|
|
import secrets
|
|
import ssl
|
|
import sys
|
|
import urllib.error
|
|
import urllib.parse
|
|
import urllib.request
|
|
from dataclasses import dataclass
|
|
from typing import Any, Dict, Optional
|
|
|
|
from store import env as _env
|
|
from store import ensure_migrated, get_auth, get_config, load_env_file, save_auth, save_config, default_dir
|
|
|
|
FLEET_AUTH_TOKEN_URL = "https://fleet-auth.prd.vn.cloud.tesla.com/oauth2/v3/token"
|
|
TESLA_AUTHORIZE_URL = "https://auth.tesla.com/oauth2/v3/authorize"
|
|
|
|
DEFAULT_AUDIENCE_EU = "https://fleet-api.prd.eu.vn.cloud.tesla.com"
|
|
DEFAULT_REDIRECT_URI = "http://localhost:18080/callback"
|
|
|
|
|
|
@dataclass
|
|
class TeslaRuntime:
|
|
# Provider creds (prefer .env)
|
|
client_id: Optional[str]
|
|
client_secret: Optional[str]
|
|
|
|
# Config
|
|
redirect_uri: str
|
|
audience: str
|
|
base_url: str
|
|
ca_cert: Optional[str]
|
|
domain: Optional[str]
|
|
|
|
# Tokens
|
|
access_token: Optional[str]
|
|
refresh_token: Optional[str]
|
|
|
|
|
|
def form_post(url: str, fields: Dict[str, str]) -> Any:
|
|
body = urllib.parse.urlencode(fields).encode("utf-8")
|
|
headers = {
|
|
"Content-Type": "application/x-www-form-urlencoded",
|
|
"Accept": "application/json",
|
|
}
|
|
req = urllib.request.Request(url=url, method="POST", data=body, headers=headers)
|
|
ctx = ssl.create_default_context()
|
|
|
|
try:
|
|
with urllib.request.urlopen(req, context=ctx) as resp:
|
|
return json.loads(resp.read().decode("utf-8"))
|
|
except urllib.error.HTTPError as e:
|
|
text = e.read().decode("utf-8", errors="replace")
|
|
try:
|
|
payload = json.loads(text)
|
|
except json.JSONDecodeError:
|
|
payload = text
|
|
raise RuntimeError(f"HTTP {e.code}: {payload}")
|
|
|
|
|
|
def http_json(method: str, url: str, token: str, json_body: Optional[Dict[str, Any]] = None, ca_cert: Optional[str] = None) -> Any:
|
|
headers = {"Accept": "application/json", "Authorization": f"Bearer {token}"}
|
|
body = None
|
|
if json_body is not None:
|
|
body = json.dumps(json_body).encode("utf-8")
|
|
headers["Content-Type"] = "application/json"
|
|
|
|
req = urllib.request.Request(url=url, method=method, data=body, headers=headers)
|
|
ctx = ssl.create_default_context(cafile=ca_cert) if ca_cert else ssl.create_default_context()
|
|
|
|
try:
|
|
with urllib.request.urlopen(req, context=ctx) as resp:
|
|
return json.loads(resp.read().decode("utf-8"))
|
|
except urllib.error.HTTPError as e:
|
|
text = e.read().decode("utf-8", errors="replace")
|
|
raise RuntimeError(f"HTTP {e.code}: {text}")
|
|
|
|
|
|
def load_runtime(dir_path: str, *, args: argparse.Namespace) -> TeslaRuntime:
|
|
load_env_file(dir_path)
|
|
ensure_migrated(dir_path)
|
|
|
|
cfg = get_config(dir_path)
|
|
auth = get_auth(dir_path)
|
|
|
|
audience = (args.audience or cfg.get("audience") or _env("TESLA_AUDIENCE") or DEFAULT_AUDIENCE_EU).strip()
|
|
redirect_uri = (args.redirect_uri or cfg.get("redirect_uri") or _env("TESLA_REDIRECT_URI") or DEFAULT_REDIRECT_URI).strip()
|
|
base_url = (args.base_url or cfg.get("base_url") or _env("TESLA_BASE_URL") or audience).strip()
|
|
|
|
return TeslaRuntime(
|
|
client_id=args.client_id or _env("TESLA_CLIENT_ID") or cfg.get("client_id"),
|
|
client_secret=args.client_secret or _env("TESLA_CLIENT_SECRET") or cfg.get("client_secret"),
|
|
redirect_uri=redirect_uri,
|
|
audience=audience,
|
|
base_url=base_url,
|
|
ca_cert=args.ca_cert or cfg.get("ca_cert") or _env("TESLA_CA_CERT"),
|
|
domain=args.domain or cfg.get("domain") or _env("TESLA_DOMAIN"),
|
|
access_token=_env("TESLA_ACCESS_TOKEN") or auth.get("access_token"),
|
|
refresh_token=_env("TESLA_REFRESH_TOKEN") or auth.get("refresh_token"),
|
|
)
|
|
|
|
|
|
def cmd_login(rt: TeslaRuntime, dir_path: str) -> int:
|
|
if not rt.client_id:
|
|
print("Missing client_id (set TESLA_CLIENT_ID in ~/.bot/tesla-fleet-api/.env)", file=sys.stderr)
|
|
return 1
|
|
|
|
scope = "openid offline_access vehicle_device_data vehicle_cmds vehicle_location"
|
|
state = secrets.token_hex(16)
|
|
|
|
params = {
|
|
"response_type": "code",
|
|
"client_id": rt.client_id,
|
|
"redirect_uri": rt.redirect_uri,
|
|
"scope": scope,
|
|
"state": state,
|
|
"locale": "en-US",
|
|
"prompt": "login",
|
|
}
|
|
|
|
url = TESLA_AUTHORIZE_URL + "?" + urllib.parse.urlencode(params)
|
|
|
|
print("Open this URL to authorize:\n")
|
|
print(url)
|
|
print("\nState:", state)
|
|
print()
|
|
|
|
code = input("Paste the 'code' from the callback URL: ").strip()
|
|
if not code:
|
|
print("No code provided.", file=sys.stderr)
|
|
return 1
|
|
|
|
return cmd_exchange(rt, dir_path, code)
|
|
|
|
|
|
def cmd_exchange(rt: TeslaRuntime, dir_path: str, code: str) -> int:
|
|
if not rt.client_id or not rt.client_secret:
|
|
print("Missing client_id/client_secret (set TESLA_CLIENT_ID and TESLA_CLIENT_SECRET in .env)", file=sys.stderr)
|
|
return 1
|
|
|
|
fields = {
|
|
"grant_type": "authorization_code",
|
|
"client_id": rt.client_id,
|
|
"client_secret": rt.client_secret,
|
|
"code": code,
|
|
"audience": rt.audience,
|
|
"redirect_uri": rt.redirect_uri,
|
|
}
|
|
|
|
try:
|
|
payload = form_post(FLEET_AUTH_TOKEN_URL, fields)
|
|
except RuntimeError as e:
|
|
print(f"Error: {e}", file=sys.stderr)
|
|
return 1
|
|
|
|
auth = get_auth(dir_path)
|
|
auth["access_token"] = payload.get("access_token")
|
|
auth["refresh_token"] = payload.get("refresh_token")
|
|
save_auth(dir_path, {k: v for k, v in auth.items() if v is not None})
|
|
|
|
print("✅ Tokens saved (auth.json)")
|
|
return 0
|
|
|
|
|
|
def cmd_refresh(rt: TeslaRuntime, dir_path: str) -> int:
|
|
if not rt.client_id or not rt.refresh_token:
|
|
print("Missing client_id or refresh_token.", file=sys.stderr)
|
|
return 1
|
|
|
|
fields = {
|
|
"grant_type": "refresh_token",
|
|
"client_id": rt.client_id,
|
|
"refresh_token": rt.refresh_token,
|
|
}
|
|
|
|
try:
|
|
payload = form_post(FLEET_AUTH_TOKEN_URL, fields)
|
|
except RuntimeError as e:
|
|
print(f"Error: {e}", file=sys.stderr)
|
|
return 1
|
|
|
|
auth = get_auth(dir_path)
|
|
auth["access_token"] = payload.get("access_token")
|
|
if payload.get("refresh_token"):
|
|
auth["refresh_token"] = payload.get("refresh_token")
|
|
save_auth(dir_path, {k: v for k, v in auth.items() if v is not None})
|
|
|
|
print("✅ Token refreshed")
|
|
return 0
|
|
|
|
|
|
def cmd_register(rt: TeslaRuntime, dir_path: str) -> int:
|
|
if not rt.domain:
|
|
print("Specify --domain or set TESLA_DOMAIN / config.json:domain", file=sys.stderr)
|
|
return 1
|
|
if not rt.client_id or not rt.client_secret:
|
|
print("Missing client_id/client_secret (set in .env)", file=sys.stderr)
|
|
return 1
|
|
|
|
# Partner token via client_credentials
|
|
fields = {
|
|
"grant_type": "client_credentials",
|
|
"client_id": rt.client_id,
|
|
"client_secret": rt.client_secret,
|
|
"audience": rt.audience,
|
|
}
|
|
|
|
try:
|
|
token_resp = form_post(FLEET_AUTH_TOKEN_URL, fields)
|
|
partner_token = token_resp.get("access_token")
|
|
except RuntimeError as e:
|
|
print(f"Error getting partner token: {e}", file=sys.stderr)
|
|
return 1
|
|
|
|
base = rt.base_url.rstrip("/")
|
|
url = f"{base}/api/1/partner_accounts"
|
|
|
|
try:
|
|
_ = http_json("POST", url, partner_token, {"domain": rt.domain}, rt.ca_cert)
|
|
except RuntimeError as e:
|
|
print(f"Error: {e}", file=sys.stderr)
|
|
return 1
|
|
|
|
cfg = get_config(dir_path)
|
|
cfg["domain"] = rt.domain
|
|
save_config(dir_path, cfg)
|
|
|
|
print(f"✅ Domain registered: {rt.domain}")
|
|
print("Next step: Enroll your key on the vehicle:")
|
|
print(f" https://tesla.com/_ak/{rt.domain}")
|
|
return 0
|
|
|
|
|
|
def cmd_config_show(rt: TeslaRuntime, dir_path: str) -> int:
|
|
print(f"📁 Config dir: {dir_path}")
|
|
print(f" - config.json : {dir_path}/config.json")
|
|
print(f" - auth.json : {dir_path}/auth.json")
|
|
print()
|
|
|
|
print(f"🔑 Client ID: {'(from env)' if _env('TESLA_CLIENT_ID') else '(not set)'}")
|
|
print(f"🔒 Client Secret: {'(from env)' if _env('TESLA_CLIENT_SECRET') else '(not set)'}")
|
|
print(f"🔗 Redirect URI: {rt.redirect_uri}")
|
|
print(f"🌍 Audience: {rt.audience}")
|
|
print(f"🖥️ Base URL: {rt.base_url}")
|
|
print(f"📜 CA Cert: {rt.ca_cert or '(not set)'}")
|
|
print(f"🏠 Domain: {rt.domain or '(not set)'}")
|
|
print()
|
|
print(f"🎫 Access Token: {'(set)' if rt.access_token else '(not set)'}")
|
|
print(f"🔄 Refresh Token: {'(set)' if rt.refresh_token else '(not set)'}")
|
|
return 0
|
|
|
|
|
|
def cmd_config_set(args: argparse.Namespace, dir_path: str) -> int:
|
|
load_env_file(dir_path)
|
|
ensure_migrated(dir_path)
|
|
|
|
cfg = get_config(dir_path)
|
|
changed = []
|
|
|
|
for key, val in (
|
|
("redirect_uri", args.redirect_uri),
|
|
("audience", args.audience),
|
|
("base_url", args.base_url),
|
|
("ca_cert", args.ca_cert),
|
|
("domain", args.domain),
|
|
):
|
|
if val is not None:
|
|
cfg[key] = val
|
|
changed.append(key)
|
|
|
|
if args.clear:
|
|
for k in args.clear:
|
|
if k in cfg:
|
|
cfg.pop(k, None)
|
|
changed.append(f"clear:{k}")
|
|
|
|
if not changed:
|
|
print("No changes specified.", file=sys.stderr)
|
|
return 1
|
|
|
|
save_config(dir_path, cfg)
|
|
print("✅ Updated:", ", ".join(changed))
|
|
return 0
|
|
|
|
|
|
def build_parser() -> argparse.ArgumentParser:
|
|
p = argparse.ArgumentParser(prog="auth.py", description="Tesla Fleet API auth/config")
|
|
p.add_argument("--dir", default=default_dir(), help="Config directory (default: ~/.bot/tesla-fleet-api)")
|
|
|
|
# optional runtime overrides
|
|
p.add_argument("--client-id")
|
|
p.add_argument("--client-secret")
|
|
p.add_argument("--redirect-uri")
|
|
p.add_argument("--audience")
|
|
p.add_argument("--base-url")
|
|
p.add_argument("--ca-cert")
|
|
p.add_argument("--domain")
|
|
|
|
sp = p.add_subparsers(dest="command", required=True)
|
|
|
|
sp.add_parser("login", help="OAuth login flow (interactive)")
|
|
|
|
p_ex = sp.add_parser("exchange", help="Exchange auth code for tokens")
|
|
p_ex.add_argument("code", help="Authorization code")
|
|
|
|
sp.add_parser("refresh", help="Refresh access token")
|
|
|
|
p_reg = sp.add_parser("register", help="Register app domain")
|
|
p_reg.add_argument("--domain")
|
|
|
|
p_cfg = sp.add_parser("config", help="Show or set config")
|
|
cfg_sp = p_cfg.add_subparsers(dest="config_action")
|
|
|
|
cfg_sp.add_parser("show", help="Show config")
|
|
|
|
p_set = cfg_sp.add_parser("set", help="Set config values")
|
|
p_set.add_argument("--redirect-uri")
|
|
p_set.add_argument("--audience")
|
|
p_set.add_argument("--base-url")
|
|
p_set.add_argument("--ca-cert")
|
|
p_set.add_argument("--domain")
|
|
p_set.add_argument("--clear", action="append", help="Remove a key from config.json (repeatable)")
|
|
|
|
return p
|
|
|
|
|
|
def main() -> int:
|
|
parser = build_parser()
|
|
args = parser.parse_args()
|
|
|
|
if args.command == "config" and args.config_action == "set":
|
|
return cmd_config_set(args, args.dir)
|
|
|
|
rt = load_runtime(args.dir, args=args)
|
|
|
|
if args.command == "login":
|
|
return cmd_login(rt, args.dir)
|
|
if args.command == "exchange":
|
|
return cmd_exchange(rt, args.dir, args.code)
|
|
if args.command == "refresh":
|
|
return cmd_refresh(rt, args.dir)
|
|
if args.command == "register":
|
|
# domain can come from args --domain for this command, override runtime
|
|
if args.domain:
|
|
rt.domain = args.domain
|
|
return cmd_register(rt, args.dir)
|
|
if args.command == "config":
|
|
return cmd_config_show(rt, args.dir)
|
|
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|