tesla 0.0.1 → 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5c27dc6f3458aabf11c477d29c0a76301e1c87f387507cf827fba13eafa29f7e
+  data.tar.gz: 5d4979456a47f1c0f54884976951ca8022b5eaeda6f090c7ae943a400be66756
+SHA512:
+  metadata.gz: 9443e63fc24709dcc3dbadaf3e7875877481d60070f4f0e911bdef0084193a55afafff5a09900c3df4910deb55e5767d9b069f5941f943595862dca2b2a0a4a5
+  data.tar.gz: 34b2fc8770cbd81abaefde5a5a0a157253caa3c7b0d57f0775ebae58d1ed29379cd7e5c9a0a66cc08df818d99db895a5278c378b3a4a249c736c7473fc6749b8

data/.yardopts

@@ -0,0 +1,5 @@
+--no-private
+--hide-api private
+--markup markdown
+--tag authenticated:"Requires Authentication"
+lib/**/*.rb

data/CHANGELOG.md

@@ -0,0 +1,31 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-10-04
+
+### Added
+* Add `vehicles`, `vehicle`, `vehicle_data`, `wake_up`, `nearby_charging_sites`, and `mobile_enabled?` for the vehicle endpoints of the Tesla Fleet API; `wake_up` takes a `timeout` to wait for the vehicle to be online
+* Add `command`, which sends any command to a vehicle, returns `true` once the vehicle has carried it out, and raises `Tesla::CommandFailed` with the reason the vehicle gave when it has not
+* Add the closure commands `lock_doors`, `unlock_doors`, `actuate_trunk`, `open_frunk`, `vent_windows`, `close_windows`, `vent_sunroof`, `close_sunroof`, and `trigger_homelink`
+* Add the climate commands `start_climate`, `stop_climate`, `set_temperature`, `set_max_defrost`, `set_seat_heater`, `set_seat_cooler`, `set_steering_wheel_heater`, `set_climate_keeper_mode`, `set_bioweapon_mode`, and `set_cabin_overheat_protection`
+* Add the charging commands `open_charge_port`, `close_charge_port`, `start_charging`, `stop_charging`, `set_charge_limit`, `set_charging_amps`, `charge_to_standard_range`, and `charge_to_max_range`
+* Add the alert commands `honk_horn` and `flash_lights`, the media commands `toggle_playback`, `next_track`, `previous_track`, `next_favorite`, `previous_favorite`, `volume_up`, `volume_down`, and `set_volume`, and the navigation commands `navigate_to` and `navigate_to_coordinates`
+* Add the security commands `set_sentry_mode`, `set_valet_mode`, `reset_valet_pin`, `remote_start`, `set_speed_limit`, `activate_speed_limit`, `deactivate_speed_limit`, and `clear_speed_limit_pin`, and the software commands `schedule_software_update` and `cancel_software_update`
+* Add `me` and `region` for the user endpoints, and `register_partner` and `partner_public_key` for the partner endpoints
+* Add OAuth 2.0 with the simple_oauth gem: `authorization_url`, `exchange_code`, `refresh_access_token`, and `partner_token`
+* Refresh the access token when the Fleet API answers that it is no longer good, for a client with a refresh token and a client ID, and call `on_token_refresh` with the new tokens
+* Wrap responses in `Vehicle`, `VehicleData`, `ChargeState`, `ClimateState`, `DriveState`, `VehicleState`, `VehicleConfig`, `GUISettings`, `NearbyChargingSites`, `ChargingSite`, `User`, and `Region` objects, which are immutable, compare by identity, match `case`/`in` patterns, inspect as short summaries, and keep `[]` and `to_h` for the raw response
+* Accept a `Vehicle` wherever a VIN or the ID of a vehicle is expected
+* Add `host`, `audience`, `authorization_endpoint`, `token_endpoint`, `user_agent`, `open_timeout`, `read_timeout`, `write_timeout`, `keep_alive_timeout`, `debug_output`, `proxy_url`, `max_redirects`, and `ca_file` options, set globally or per client; the credentials fall back to the `TESLA_ACCESS_TOKEN`, `TESLA_REFRESH_TOKEN`, `TESLA_CLIENT_ID`, `TESLA_CLIENT_SECRET`, and `TESLA_REDIRECT_URI` environment variables, and the host to `TESLA_HOST`
+* Add `max_retries` and `max_retry_delay` options: a 429 is sent again twice by default, honoring `Retry-After`, as is a 502, 503, or 504, or a request the network lost, for the requests that only ask for something; a command is never sent a second time
+* Reuse connections across the requests to the same host that only ask for something; `Client#close` closes them, and a client built with a block closes them when the block returns
+* Follow redirects, up to `max_redirects` times, without the access token when one leads to another host, and never with the body of a request to another host
+* Redact the access token, the tokens and the client secret of a token request and its response, and the PIN or password of a command from `debug_output`
+* Raise an error named for the HTTP status of an unsuccessful response, such as `Tesla::RequestTimeout` for a vehicle that is asleep, each a `Tesla::HTTPError` and a `Tesla::Error`, with the error the Fleet API describes as its message
+* Ship RBS signatures

data/CONTRIBUTING.md

@@ -0,0 +1,45 @@
+## Contributing
+In the spirit of [free software][free-sw], **everyone** is encouraged to help improve this project.
+
+Here are some ways *you* can contribute:
+
+* by using alpha, beta, and prerelease versions
+* by reporting bugs
+* by suggesting new features
+* by writing or editing documentation
+* by writing specifications
+* by writing code (**no patch is too small**: fix typos, add comments, clean up
+  inconsistent whitespace)
+* by refactoring code
+* by closing [issues][]
+* by reviewing patches
+
+## Submitting an Issue
+We use the [GitHub issue tracker][issues] to track bugs and features. Before
+submitting a bug report or feature request, check to make sure it hasn't
+already been submitted. When submitting a bug report, please include a [Gist][]
+that includes a stack trace and any details that may be necessary to reproduce
+the bug, including your gem version, Ruby version, and operating system.
+Ideally, a bug report should include a pull request with failing specs.
+
+## Submitting a Pull Request
+1. [Fork the repository.][fork]
+2. [Create a topic branch.][branch]
+3. Add specs for your unimplemented feature or bug fix.
+4. Run `bundle exec rake spec`. If your specs pass, return to step 3.
+5. Implement your feature or bug fix.
+6. Run `bundle exec rake spec`. If your specs fail, return to step 5.
+7. Run `bundle exec rake mutant`. If any mutations survive, return to step 3.
+8. Add documentation and type signatures (in `sig/tesla.rbs`) for your feature
+   or bug fix.
+9. Run `bundle exec rake`. If the linters, type checker, or documentation
+   checks fail, go back to step 8.
+10. Add, commit, and push your changes.
+11. [Submit a pull request.][pr]
+
+[free-sw]: http://www.fsf.org/licensing/essays/free-sw.html
+[issues]: https://github.com/sferik/tesla-ruby/issues
+[gist]: https://gist.github.com/
+[fork]: http://help.github.com/fork-a-repo/
+[branch]: http://learn.github.com/p/branching.html
+[pr]: http://help.github.com/send-pull-requests/

data/{LICENSE.txt → LICENSE.md}

@@ -1,4 +1,4 @@
-Copyright (c) 2011 Jesse Cooke
+Copyright (c) 2026 Erik Berlin
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -0,0 +1,366 @@
+# Tesla
+
+[![tests](https://github.com/sferik/tesla-ruby/actions/workflows/test.yml/badge.svg)](https://github.com/sferik/tesla-ruby/actions/workflows/test.yml)
+[![mutation tests](https://github.com/sferik/tesla-ruby/actions/workflows/mutant.yml/badge.svg)](https://github.com/sferik/tesla-ruby/actions/workflows/mutant.yml)
+[![linter](https://github.com/sferik/tesla-ruby/actions/workflows/lint.yml/badge.svg)](https://github.com/sferik/tesla-ruby/actions/workflows/lint.yml)
+[![type checker](https://github.com/sferik/tesla-ruby/actions/workflows/steep.yml/badge.svg)](https://github.com/sferik/tesla-ruby/actions/workflows/steep.yml)
+[![docs](https://github.com/sferik/tesla-ruby/actions/workflows/docs.yml/badge.svg)](https://github.com/sferik/tesla-ruby/actions/workflows/docs.yml)
+
+Ruby wrapper for the [Tesla Fleet API](https://developer.tesla.com/docs/fleet-api).
+
+## Installation
+
+Install the gem and add to the application's Gemfile:
+
+    bundle add tesla
+
+Or, if Bundler is not being used to manage dependencies:
+
+    gem install tesla
+
+## Usage Examples
+
+```ruby
+require 'tesla'
+
+Tesla.access_token = 'eyJhbGciOiJSUzI1NiIs...'
+
+# Return the vehicles of the account.
+car = Tesla.vehicles.first
+car.vin              # => "5YJSA11111111111"
+car.display_name     # => "Nikola 2.0"
+car.state            # => "asleep"
+
+# Wake the car, and wait up to a minute for it to be online.
+car = Tesla.wake_up car, timeout: 60
+car.online?          # => true
+
+# Pop the trunk. A powered liftgate that is open closes again.
+Tesla.actuate_trunk car
+
+# Open the frunk.
+Tesla.open_frunk car
+
+# Set the temperature, in degrees Celsius, and turn on the climate control.
+Tesla.set_temperature car, 21.5
+Tesla.start_climate car
+
+# Heat the driver's seat, and the steering wheel.
+Tesla.set_seat_heater car, :front_left, 3
+Tesla.set_steering_wheel_heater car, on: true
+
+# Keep the dog cool.
+Tesla.set_climate_keeper_mode car, :dog
+
+# Lock and unlock the doors.
+Tesla.lock_doors car
+Tesla.unlock_doors car
+
+# Vent the windows, and close them again.
+Tesla.vent_windows car
+Tesla.close_windows car
+
+# Find the car in a parking lot.
+Tesla.flash_lights car
+Tesla.honk_horn car
+
+# Charge to 80%, at 32 amps.
+Tesla.set_charge_limit car, 80
+Tesla.set_charging_amps car, 32
+Tesla.open_charge_port car
+Tesla.start_charging car
+
+# Send a destination to the navigation.
+Tesla.navigate_to car, '3500 Deer Creek Road, Palo Alto, CA'
+
+# Turn on Sentry Mode.
+Tesla.set_sentry_mode car, on: true
+
+# A VIN stands in for the car wherever one is expected.
+Tesla.lock_doors '5YJSA11111111111'
+
+# Send a command the library has no method for.
+Tesla.command car, :set_vehicle_name, vehicle_name: 'Nikola 2.0'
+```
+
+Every command returns `true` once the car has carried it out. Each is documented, with its parameters, in the
+mixin of [`Tesla::API`](https://www.rubydoc.info/gems/tesla/Tesla/API) it belongs to:
+
+| Mixin | Commands |
+| ----- | -------- |
+| `ClosureEndpoints` | `lock_doors`, `unlock_doors`, `actuate_trunk`, `open_frunk`, `vent_windows`, `close_windows`, `vent_sunroof`, `close_sunroof`, `trigger_homelink` |
+| `ClimateEndpoints` | `start_climate`, `stop_climate`, `set_temperature`, `set_max_defrost`, `set_seat_heater`, `set_seat_cooler`, `set_steering_wheel_heater`, `set_climate_keeper_mode`, `set_bioweapon_mode`, `set_cabin_overheat_protection` |
+| `ChargingEndpoints` | `open_charge_port`, `close_charge_port`, `start_charging`, `stop_charging`, `set_charge_limit`, `set_charging_amps`, `charge_to_standard_range`, `charge_to_max_range` |
+| `AlertEndpoints` | `honk_horn`, `flash_lights` |
+| `MediaEndpoints` | `toggle_playback`, `next_track`, `previous_track`, `next_favorite`, `previous_favorite`, `volume_up`, `volume_down`, `set_volume` |
+| `NavigationEndpoints` | `navigate_to`, `navigate_to_coordinates` |
+| `SecurityEndpoints` | `set_sentry_mode`, `set_valet_mode`, `reset_valet_pin`, `remote_start`, `set_speed_limit`, `activate_speed_limit`, `deactivate_speed_limit`, `clear_speed_limit_pin` |
+| `SoftwareEndpoints` | `schedule_software_update`, `cancel_software_update` |
+
+### Reading the state of the car
+
+```ruby
+data = Tesla.vehicle_data car
+
+data.charge_state.battery_level        # => 59
+data.charge_state.battery_range        # => 149.92, in miles
+data.charge_state.charging_state       # => "Charging"
+data.climate_state.inside_temp         # => 22.1, in degrees Celsius
+data.climate_state.climate_on?         # => false
+data.vehicle_state.locked?             # => true
+data.vehicle_state.trunk_open?         # => false
+data.vehicle_state.odometer            # => 57869.762487, in miles
+data.vehicle_config.car_type           # => "modely"
+data.gui_settings.temperature_units    # => "F"
+
+# The Fleet API answers with the position of the car only when it is asked for,
+# for an access token with the vehicle_location scope.
+data = Tesla.vehicle_data car, endpoints: %i[location_data drive_state]
+data.drive_state.latitude              # => 33.111111
+
+# The charging sites near the car.
+Tesla.nearby_charging_sites(car).superchargers.map(&:name)
+
+# The user the access token was issued for.
+Tesla.me.email
+```
+
+Responses are immutable objects with a reader for the fields used most. Every field of the response is kept, and
+read with `[]` or `to_h`:
+
+```ruby
+data.charge_state[:charge_energy_added]   # => 2.42
+data.to_h                                 # => {"id" => 12345678901234567, ...}
+
+case Tesla.vehicle(car)
+in {state: "online"} then puts "ready"
+in {state:} then puts "the car is #{state}"
+end
+```
+
+## Using it with your own car
+
+The Fleet API is not only for fleets: it is the API Tesla offers for any car, and an application that commands a
+single car of your own is set up the same way as one that commands thousands. No approval to manage a fleet is
+involved, but there is some setup, which Tesla describes in its
+[getting started guide](https://developer.tesla.com/docs/fleet-api/getting-started/what-is-fleet-api):
+
+1. Create an application at [developer.tesla.com](https://developer.tesla.com) with the Tesla account that owns the
+   car, which issues a client ID and a client secret.
+2. Generate a key pair, and serve the public key from a domain of yours at
+   `/.well-known/appspecific/com.tesla.3p.public-key.pem`.
+3. Register the application in your region with `Tesla.register_partner`.
+4. Authorize the application for your own account (see [Authentication](#authentication)), and keep the refresh
+   token.
+5. Add the key of the application to the car, by opening `https://tesla.com/_ak/your-domain.example` on the phone
+   that has the Tesla app.
+6. Run the [vehicle command proxy](#the-vehicle-command-proxy) with the private key, and point the library at it.
+
+## Authentication
+
+Requests are authorized with an OAuth 2.0 access token, which Tesla issues to an application registered at
+[developer.tesla.com](https://developer.tesla.com). The OAuth 2.0 requests are built by the
+[simple_oauth](https://github.com/laserlemon/simple_oauth) gem.
+
+```ruby
+Tesla.configure do |config|
+  config.client_id = '81527cff06843c8634fdc09e8ac0abef'
+  config.client_secret = 'ta-secret.7vx6VkVvk2gBgSrN'
+  config.redirect_uri = 'https://example.com/auth/callback'
+end
+```
+
+Each of those falls back to an environment variable until it is assigned: `TESLA_CLIENT_ID`, `TESLA_CLIENT_SECRET`,
+`TESLA_REDIRECT_URI`, `TESLA_ACCESS_TOKEN`, and `TESLA_REFRESH_TOKEN`.
+
+```ruby
+# 1. Register the application in the region it is used in, once.
+Tesla.register_partner 'example.com'
+
+# 2. Send the owner of the car to authorize the application.
+state = SecureRandom.hex
+redirect_to Tesla.authorization_url(state: state)
+
+# 3. Tesla sends them back to the redirect URI with a code. Check the state, and exchange the code for tokens.
+response = SimpleOAuth::OAuth2::AuthorizationResponse.parse(request.query_string, state: state)
+token = Tesla.exchange_code response.code
+
+token.access_token    # lasts eight hours
+token.refresh_token   # lasts three months, and is used once
+token.expires_at      # => 2026-10-04 20:00:00 UTC
+```
+
+The module keeps the tokens, and authorizes its requests with them from then on. In another process, start from the
+tokens that were stored:
+
+```ruby
+Tesla.configure do |config|
+  config.access_token = stored.access_token
+  config.refresh_token = stored.refresh_token
+end
+```
+
+### Refreshing the access token
+
+A client with a refresh token and a client ID asks for a new access token when the Fleet API answers that the one it
+sent is no longer good, and sends the request again. One with a refresh token and no access token asks for one before
+its first request.
+
+A refresh token is used once: each refresh answers with another, which is the one the next refresh needs. Store the
+new tokens whenever they change:
+
+```ruby
+Tesla.on_token_refresh = ->(token) { store(token.access_token, token.refresh_token) }
+
+# Refresh ahead of time, rather than when a request is turned away.
+Tesla.refresh_access_token
+```
+
+## The vehicle command proxy
+
+Most cars built since 2021 only take commands signed with the
+[Tesla Vehicle Command Protocol](https://github.com/teslamotors/vehicle-command), and the Fleet API answers an
+unsigned one with a `Tesla::Forbidden`. Tesla's
+[vehicle command proxy](https://github.com/teslamotors/vehicle-command#using-the-http-proxy) signs commands with the
+private key of your application, and hands every other request on to the Fleet API. Point the library at it:
+
+```ruby
+Tesla.configure do |config|
+  config.host = 'https://localhost:4443'
+  # Trust the certificate the proxy was started with. TLS verification is never turned off.
+  config.ca_file = 'config/tls-cert.pem'
+  # Tokens are issued for the Fleet API of your region rather than for the proxy.
+  config.audience = Tesla::Configuration::NORTH_AMERICA_HOST
+end
+```
+
+The proxy knows a car by its VIN, which is what the library sends for a `Tesla::Vehicle`.
+
+## Configuration
+
+```ruby
+Tesla.configure do |config|
+  # The Fleet API of your region: NORTH_AMERICA_HOST (the default), EUROPE_HOST, or CHINA_HOST.
+  # Tesla.region.fleet_api_base_url names the one an account is served by.
+  config.host = Tesla::Configuration::EUROPE_HOST
+
+  config.open_timeout = 10      # seconds, 60 by default
+  config.read_timeout = 30      # seconds, 60 by default
+  config.write_timeout = 30     # seconds, 60 by default
+  config.keep_alive_timeout = 2 # seconds an idle connection is kept open, the default; 0 opens one per request
+  config.max_redirects = 10     # the default
+  config.proxy_url = 'http://proxy.example.com:8080'
+  config.user_agent = 'MyApp/1.0'
+  config.max_retries = 2        # the default; 0 turns retrying off
+  config.max_retry_delay = 60   # seconds, the default
+end
+```
+
+Every option can be given to a client of its own instead, which is how several accounts are used at once:
+
+```ruby
+client = Tesla::Client.new(access_token: 'eyJhbGciOiJSUzI1NiIs...', host: Tesla::Configuration::EUROPE_HOST)
+client.vehicles
+client.actuate_trunk '5YJSA11111111111'
+
+# A request of your own, for an endpoint the library has no method for.
+client.get '/api/1/vehicles/5YJSA11111111111/release_notes'
+```
+
+### Connections
+
+A request that only asks for something is sent on the connection the request before it left open, so a series of
+them does not open a connection each. A command is sent on a connection of its own, which is closed afterwards, since
+a command sent on a connection the server has closed could not be sent again. `Client#close` closes the connections
+a client keeps open, and a client built with a block closes them when the block returns:
+
+```ruby
+Tesla::Client.new(access_token: 'eyJhbGciOiJSUzI1NiIs...') do |client|
+  client.vehicles.each { |car| puts client.vehicle_data(car).charge_state.battery_level }
+end
+```
+
+### Redirects
+
+A redirect is followed, up to `max_redirects` times. One to another scheme, host, or port is followed without the
+access token and without the headers of the caller, and one that would send the body of a request to another host
+is not followed at all.
+
+### Debug output
+
+```ruby
+Tesla.debug_output = $stderr
+```
+
+Every request and response is written to the IO, with the credentials they carry redacted: the `Authorization` and
+`Proxy-Authorization` headers, the tokens and the client secret of a request to the token endpoint and of its
+response, and the PIN or password of a command.
+
+### Retries
+
+A request the Fleet API rate limited (429) is sent again, up to `max_retries` times, after the wait its `Retry-After`
+header asks for. A request that only asks for something is also sent again after a 502, 503, or 504, or when the
+network loses it. A command is not: the car may have carried it out before the answer went missing, and a trunk asked
+to open twice closes again.
+
+## Errors
+
+Every error the library raises is a `Tesla::Error`.
+
+```ruby
+begin
+  Tesla.start_charging car
+rescue Tesla::CommandFailed => e
+  e.reason            # => "disconnected": the car read the command and refused
+rescue Tesla::RequestTimeout
+  Tesla.wake_up car, timeout: 60   # the car is asleep or offline
+  retry
+rescue Tesla::TooManyRequests => e
+  sleep e.retry_after
+  retry
+rescue Tesla::HTTPError => e
+  e.code              # => 403
+  e.message           # => the error the Fleet API describes
+end
+```
+
+| Error | Raised when |
+| ----- | ----------- |
+| `Tesla::CommandFailed` | the car answers that it did not carry out a command |
+| `Tesla::VehicleAsleep` | the car is not online once the `timeout` of `wake_up` is over |
+| `Tesla::OAuthError` | the token endpoint turns a request for a token away |
+| `Tesla::NetworkError` | the request is lost to the network |
+| `Tesla::TooManyRedirects` | a request is redirected more than `max_redirects` times |
+| `Tesla::InvalidResponse` | a successful response cannot be read |
+| `Tesla::HTTPError` | the response is not successful; its subclasses are named for the status, and are each a `Tesla::ClientError` or a `Tesla::ServerError` |
+
+The statuses the Fleet API gives a meaning of its own:
+
+| Status | Error | Meaning |
+| ------ | ----- | ------- |
+| 401 | `Tesla::Unauthorized` | the access token is missing, expired, or revoked |
+| 403 | `Tesla::Forbidden` | the token lacks a scope, or the car takes only signed commands |
+| 408 | `Tesla::RequestTimeout` | the car is asleep or offline |
+| 412 | `Tesla::PreconditionFailed` | the application is not registered in the region |
+| 421 | `Tesla::MisdirectedRequest` | the account belongs to another region |
+| 429 | `Tesla::TooManyRequests` | the application is rate limited |
+| 540 | `Tesla::DeviceUnexpectedResponse` | the car answered with an error |
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rake` to run the specs,
+the linters, the mutation tests, the type checker, and the documentation checks. `bin/console` opens an interactive
+prompt.
+
+The library is tested on Ruby 3.4, Ruby 4.0, and JRuby 10, on Linux, macOS, and Windows.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/sferik/tesla-ruby. See
+[CONTRIBUTING.md](CONTRIBUTING.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](LICENSE.md).
+
+This project is not affiliated with or endorsed by Tesla, Inc.

data/SECURITY.md

@@ -0,0 +1,38 @@
+# Security Policy
+
+## Supported versions
+
+Security fixes are released for the most recent minor release of the current major series.
+
+## Reporting a vulnerability
+
+Please do not report security vulnerabilities through public GitHub issues, pull requests, or discussions.
+
+Report them privately through [GitHub security advisories](https://github.com/sferik/tesla-ruby/security/advisories/new),
+or by email to [sferik@gmail.com](mailto:sferik@gmail.com). Include the version of the gem, the Ruby version, and the
+steps to reproduce the problem.
+
+## What this library handles
+
+This library sends credentials to the Tesla Fleet API and to Tesla's authorization server: OAuth 2.0 access tokens,
+refresh tokens, and the client secret of an application. Those credentials can unlock and start a car, so reports
+about the way they are stored, sent, logged, or resolved are particularly welcome. It already takes these
+precautions, so a way around one of them is a vulnerability rather than a feature request:
+
+* `inspect` output for clients and authenticators never includes credentials.
+* The values interpolated into request paths are escaped, so a vehicle tag or a command name holding a slash cannot
+  walk out of the endpoint it was meant for and take the access token of the request with it.
+* A request path that is a URL of another host, or that climbs out of the path prefix of the host, is refused rather
+  than sent the access token.
+* Credentials are redacted from `debug_output`, which Net::HTTP would otherwise write in the clear: the
+  `Authorization` header of a request, the `Proxy-Authorization` header of a request sent through a proxy and of
+  the CONNECT that opens a TLS connection through one, the tokens and the client secret of a request to the token
+  endpoint and of its response, and the PIN or password of a command.
+* A redirect to another scheme, host, or port is followed without the access token or the caller's headers, and one
+  that would send the body of the request again is not followed at all, so that a command cannot be replayed to a
+  host the client was not pointed at.
+* A command is never sent a second time on its own: a request that asks a vehicle to do something is retried only
+  when a rate limiter turned it away before it reached the vehicle, and is sent on a connection of its own rather
+  than on one kept open, which the server may have closed.
+* TLS certificates are verified, and no option turns that off: a host whose certificate OpenSSL does not already
+  trust, such as the vehicle command proxy, is reached by naming that certificate with `ca_file`.

data/lib/tesla/api/alert_endpoints.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Tesla
+  module API
+    # The alert commands, which draw attention to a vehicle
+    # @api public
+    module AlertEndpoints
+      # Honk the horn of a vehicle
+      #
+      # @api public
+      # @authenticated true
+      # @param vehicle [String, Integer, Vehicle] The VIN or ID of a vehicle, or a vehicle.
+      # @return [true] once the vehicle has carried out the command
+      # @raise [CommandFailed] if the vehicle answers that it did not carry out the command
+      # @example
+      #   Tesla.honk_horn "5YJSA11111111111"
+      def honk_horn(vehicle)
+        command(vehicle, "honk_horn")
+      end
+
+      # Flash the headlights of a vehicle
+      #
+      # @api public
+      # @authenticated true
+      # @param vehicle [String, Integer, Vehicle] The VIN or ID of a vehicle, or a vehicle.
+      # @return [true] once the vehicle has carried out the command
+      # @raise [CommandFailed] if the vehicle answers that it did not carry out the command
+      # @example
+      #   Tesla.flash_lights "5YJSA11111111111"
+      def flash_lights(vehicle)
+        command(vehicle, "flash_lights")
+      end
+    end
+  end
+end

data/lib/tesla/api/charging_endpoints.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Tesla
+  module API
+    # The charging commands, which control how a vehicle charges
+    # @api public
+    module ChargingEndpoints
+      # Open the charge port of a vehicle, or unlock the cable in it
+      #
+      # @api public
+      # @authenticated true
+      # @param vehicle [String, Integer, Vehicle] The VIN or ID of a vehicle, or a vehicle.
+      # @return [true] once the vehicle has carried out the command
+      # @raise [CommandFailed] if the vehicle answers that it did not carry out the command
+      # @example
+      #   Tesla.open_charge_port "5YJSA11111111111"
+      def open_charge_port(vehicle)
+        command(vehicle, "charge_port_door_open")
+      end
+
+      # Close the charge port of a vehicle
+      #
+      # @api public
+      # @authenticated true
+      # @param vehicle [String, Integer, Vehicle] The VIN or ID of a vehicle, or a vehicle.
+      # @return [true] once the vehicle has carried out the command
+      # @raise [CommandFailed] if the vehicle answers that it did not carry out the command
+      # @example
+      #   Tesla.close_charge_port "5YJSA11111111111"
+      def close_charge_port(vehicle)
+        command(vehicle, "charge_port_door_close")
+      end
+
+      # Start charging a vehicle
+      #
+      # @api public
+      # @authenticated true
+      # @param vehicle [String, Integer, Vehicle] The VIN or ID of a vehicle, or a vehicle.
+      # @return [true] once the vehicle has carried out the command
+      # @raise [CommandFailed] if the vehicle answers that it did not carry out the command
+      # @example
+      #   Tesla.start_charging "5YJSA11111111111"
+      def start_charging(vehicle)
+        command(vehicle, "charge_start")
+      end
+
+      # Stop charging a vehicle
+      #
+      # @api public
+      # @authenticated true
+      # @param vehicle [String, Integer, Vehicle] The VIN or ID of a vehicle, or a vehicle.
+      # @return [true] once the vehicle has carried out the command
+      # @raise [CommandFailed] if the vehicle answers that it did not carry out the command
+      # @example
+      #   Tesla.stop_charging "5YJSA11111111111"
+      def stop_charging(vehicle)
+        command(vehicle, "charge_stop")
+      end
+
+      # Set the charge a vehicle stops charging at
+      #
+      # @api public
+      # @authenticated true
+      # @param vehicle [String, Integer, Vehicle] The VIN or ID of a vehicle, or a vehicle.
+      # @param percent [Integer] The charge to stop at, as a percentage.
+      # @return [true] once the vehicle has carried out the command
+      # @raise [CommandFailed] if the vehicle answers that it did not carry out the command
+      # @example
+      #   Tesla.set_charge_limit "5YJSA11111111111", 80
+      def set_charge_limit(vehicle, percent)
+        command(vehicle, "set_charge_limit", percent:)
+      end
+
+      # Set the current a vehicle charges with
+      #
+      # @api public
+      # @authenticated true
+      # @param vehicle [String, Integer, Vehicle] The VIN or ID of a vehicle, or a vehicle.
+      # @param amps [Integer] The current in amps.
+      # @return [true] once the vehicle has carried out the command
+      # @raise [CommandFailed] if the vehicle answers that it did not carry out the command
+      # @example
+      #   Tesla.set_charging_amps "5YJSA11111111111", 32
+      def set_charging_amps(vehicle, amps)
+        command(vehicle, "set_charging_amps", charging_amps: amps)
+      end
+
+      # Set the charge limit of a vehicle to the one Tesla recommends for daily driving
+      #
+      # @api public
+      # @authenticated true
+      # @param vehicle [String, Integer, Vehicle] The VIN or ID of a vehicle, or a vehicle.
+      # @return [true] once the vehicle has carried out the command
+      # @raise [CommandFailed] if the vehicle answers that it did not carry out the command
+      # @example
+      #   Tesla.charge_to_standard_range "5YJSA11111111111"
+      def charge_to_standard_range(vehicle)
+        command(vehicle, "charge_standard")
+      end
+
+      # Set the charge limit of a vehicle to the whole of its battery
+      #
+      # @api public
+      # @authenticated true
+      # @param vehicle [String, Integer, Vehicle] The VIN or ID of a vehicle, or a vehicle.
+      # @return [true] once the vehicle has carried out the command
+      # @raise [CommandFailed] if the vehicle answers that it did not carry out the command
+      # @example
+      #   Tesla.charge_to_max_range "5YJSA11111111111"
+      def charge_to_max_range(vehicle)
+        command(vehicle, "charge_max_range")
+      end
+    end
+  end
+end