rivian-mcp 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Patrick Heneise
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,78 @@
+# Rivian MCP
+
+Read-only [MCP server](https://modelcontextprotocol.io) for the unofficial Rivian GraphQL API. Check your vehicle's battery, range, OTA updates, charging status, and more — right from Claude.
+
+**Strictly read-only** — no vehicle commands, no settings changes.
+
+## Setup
+
+```bash
+claude mcp add rivian \
+  -e RIVIAN_EMAIL=your@email.com \
+  -e RIVIAN_PASSWORD=your-password \
+  -- npx rivian-mcp
+```
+
+<details>
+<summary>Manual config</summary>
+
+Add to `~/.claude.json` or your project's `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "rivian": {
+      "command": "npx",
+      "args": ["rivian-mcp"],
+      "env": {
+        "RIVIAN_EMAIL": "your@email.com",
+        "RIVIAN_PASSWORD": "your-password"
+      }
+    }
+  }
+}
+```
+
+</details>
+
+### First-time login
+
+Rivian requires 2FA on every new login:
+
+1. Ask Claude: **"Log in to Rivian"**
+2. Rivian sends a verification code to your phone/email
+3. Tell Claude the code: **"The code is 123456"**
+
+Your session is saved to `~/.rivian-mcp/session.json` and reused automatically until it expires (7 days).
+
+## What you can ask
+
+- "What's my battery level?"
+- "Is there a software update available?"
+- "Are all the doors locked?"
+- "Show me the full vehicle status"
+- "Who has keys to my R1S?"
+- "Am I currently charging?"
+
+## Tools
+
+| Tool | What it does |
+|---|---|
+| `rivian_login` | Start sign-in (triggers verification code) |
+| `rivian_submit_otp` | Complete sign-in with the verification code |
+| `rivian_get_user_info` | Your account, vehicles, and software versions |
+| `rivian_get_vehicle_state` | Live status — battery, doors, tires, location, climate, OTA |
+| `rivian_get_ota_status` | Current and available software versions |
+| `rivian_get_charging_session` | Active charging session details |
+| `rivian_get_drivers_and_keys` | Drivers and their phone keys / key fobs |
+
+## Requirements
+
+- Node.js 24+
+- A Rivian account with a vehicle
+
+## References
+
+- [Unofficial Rivian API Docs](https://rivian-api.kaedenb.org/app/)
+- [rivian-python-client](https://github.com/bretterer/rivian-python-client) — Python client this is based on
+- [home-assistant-rivian](https://github.com/bretterer/home-assistant-rivian) — Home Assistant integration

package/lib/rivian.js

@@ -0,0 +1,379 @@
+/**
+ * Rivian API — READ ONLY
+ *
+ * Based on bretterer/rivian-python-client and rivian-api.kaedenb.org docs.
+ * No write/post/patch mutations — only auth and queries.
+ */
+
+const GRAPHQL_GATEWAY = 'https://rivian.com/api/gql/gateway/graphql';
+const GRAPHQL_CHARGING = 'https://rivian.com/api/gql/chrg/user/graphql';
+const APOLLO_CLIENT_NAME = 'com.rivian.ios.consumer-apollo-ios';
+
+const BASE_HEADERS = {
+  'User-Agent': 'RivianApp/707 CFNetwork/1237 Darwin/20.4.0',
+  'Accept': 'application/json',
+  'Content-Type': 'application/json',
+  'Apollographql-Client-Name': APOLLO_CLIENT_NAME,
+};
+
+// ── Session state ───────────────────────────────────────────────────
+
+let csrfToken = '';
+let appSessionToken = '';
+let accessToken = '';
+let refreshToken = '';
+let userSessionToken = '';
+let otpToken = '';
+
+export const needsOtp = () => !!otpToken;
+export const isAuthenticated = () => !!accessToken;
+
+// ── Auth ────────────────────────────────────────────────────────────
+
+export async function createCsrfToken() {
+  const data = await gql(GRAPHQL_GATEWAY, {
+    operationName: 'CreateCSRFToken',
+    query: `mutation CreateCSRFToken {
+  createCsrfToken {
+    __typename
+    csrfToken
+    appSessionToken
+  }
+}`,
+    variables: null,
+  });
+  csrfToken = data.createCsrfToken.csrfToken;
+  appSessionToken = data.createCsrfToken.appSessionToken;
+}
+
+export async function login(email, password) {
+  const data = await gql(
+    GRAPHQL_GATEWAY,
+    {
+      operationName: 'Login',
+      query: `mutation Login($email: String!, $password: String!) {
+  login(email: $email, password: $password) {
+    __typename
+    ... on MobileLoginResponse {
+      __typename
+      accessToken
+      refreshToken
+      userSessionToken
+    }
+    ... on MobileMFALoginResponse {
+      __typename
+      otpToken
+    }
+  }
+}`,
+      variables: { email, password },
+    },
+    { 'Csrf-Token': csrfToken, 'A-Sess': appSessionToken },
+  );
+
+  if (data.login.otpToken) {
+    otpToken = data.login.otpToken;
+    return { mfa: true };
+  }
+
+  accessToken = data.login.accessToken;
+  refreshToken = data.login.refreshToken;
+  userSessionToken = data.login.userSessionToken;
+  return { mfa: false };
+}
+
+export async function validateOtp(email, otpCode) {
+  const data = await gql(
+    GRAPHQL_GATEWAY,
+    {
+      operationName: 'LoginWithOTP',
+      query: `mutation LoginWithOTP($email: String!, $otpCode: String!, $otpToken: String!) {
+  loginWithOTP(email: $email, otpCode: $otpCode, otpToken: $otpToken) {
+    __typename
+    ... on MobileLoginResponse {
+      __typename
+      accessToken
+      refreshToken
+      userSessionToken
+    }
+  }
+}`,
+      variables: { email, otpCode, otpToken },
+    },
+    { 'Csrf-Token': csrfToken, 'A-Sess': appSessionToken },
+  );
+
+  accessToken = data.loginWithOTP.accessToken;
+  refreshToken = data.loginWithOTP.refreshToken;
+  userSessionToken = data.loginWithOTP.userSessionToken;
+  otpToken = '';
+}
+
+// ── Read-only queries ───────────────────────────────────────────────
+
+export async function getUserInfo() {
+  const body = {
+    operationName: 'getUserInfo',
+    query: `query getUserInfo {
+  currentUser {
+    __typename
+    id
+    firstName
+    lastName
+    email
+    vehicles {
+      id
+      vin
+      name
+      roles
+      state
+      createdAt
+      updatedAt
+      vas { __typename vasVehicleId vehiclePublicKey }
+      vehicle {
+        __typename
+        id
+        vin
+        modelYear
+        make
+        model
+        expectedBuildDate
+        plannedBuildDate
+        otaEarlyAccessStatus
+        currentOTAUpdateDetails { url version locale }
+        availableOTAUpdateDetails { url version locale }
+        vehicleState {
+          supportedFeatures { __typename name status }
+        }
+      }
+    }
+    registrationChannels { type }
+  }
+}`,
+    variables: null,
+  };
+
+  return (await gql(GRAPHQL_GATEWAY, body, authHeaders())).currentUser;
+}
+
+export async function getVehicleState(vehicleId, properties) {
+  const props = properties || DEFAULT_VEHICLE_STATE_PROPERTIES;
+  const fragment = [...props]
+    .map((p) => `${p} ${TEMPLATE_MAP[p] || VALUE_TEMPLATE}`)
+    .join('\n    ');
+
+  const body = {
+    operationName: 'GetVehicleState',
+    query: `query GetVehicleState($vehicleID: String!) {
+  vehicleState(id: $vehicleID) {
+    ${fragment}
+  }
+}`,
+    variables: { vehicleID: vehicleId },
+  };
+
+  return (await gql(GRAPHQL_GATEWAY, body, authHeaders())).vehicleState;
+}
+
+export async function getOTAUpdateDetails(vehicleId) {
+  const body = {
+    operationName: 'getOTAUpdateDetails',
+    query: `query getOTAUpdateDetails($vehicleId: String!) {
+  getVehicle(id: $vehicleId) {
+    availableOTAUpdateDetails { url version locale }
+    currentOTAUpdateDetails { url version locale }
+  }
+}`,
+    variables: { vehicleId },
+  };
+
+  return (await gql(GRAPHQL_GATEWAY, body, authHeaders())).getVehicle;
+}
+
+export async function getLiveChargingSession(vehicleId) {
+  const body = {
+    operationName: 'getLiveSessionData',
+    query: `query getLiveSessionData($vehicleId: ID!) {
+  getLiveSessionData(vehicleId: $vehicleId) {
+    __typename
+    chargerId
+    current { __typename value updatedAt }
+    currentCurrency
+    currentMiles { __typename value updatedAt }
+    currentPrice
+    isFreeSession
+    isRivianCharger
+    kilometersChargedPerHour { __typename value updatedAt }
+    locationId
+    power { __typename value updatedAt }
+    rangeAddedThisSession { __typename value updatedAt }
+    soc { __typename value updatedAt }
+    startTime
+    timeElapsed
+    timeRemaining { __typename value updatedAt }
+    totalChargedEnergy { __typename value updatedAt }
+    vehicleChargerState { __typename value updatedAt }
+  }
+}`,
+    variables: { vehicleId },
+  };
+
+  return (await gql(GRAPHQL_CHARGING, body, chargingHeaders())).getLiveSessionData;
+}
+
+export async function getDriversAndKeys(vehicleId) {
+  const body = {
+    operationName: 'DriversAndKeys',
+    query: `query DriversAndKeys($vehicleId: String) {
+  getVehicle(id: $vehicleId) {
+    __typename
+    id
+    vin
+    invitedUsers {
+      __typename
+      ... on ProvisionedUser {
+        firstName lastName email roles userId
+        devices { type mappedIdentityId id hrid deviceName isPaired isEnabled }
+      }
+      ... on UnprovisionedUser {
+        email inviteId status
+      }
+    }
+  }
+}`,
+    variables: { vehicleId },
+  };
+
+  return (await gql(GRAPHQL_GATEWAY, body, authHeaders())).getVehicle;
+}
+
+// ── Session persistence ──────────────────────────────────────────────
+
+export function exportSession() {
+  return {
+    csrfToken,
+    appSessionToken,
+    accessToken,
+    refreshToken,
+    userSessionToken,
+    otpToken,
+    needsOtp: !!otpToken,
+    authenticated: !!accessToken,
+  };
+}
+
+export function restoreSession(session) {
+  csrfToken = session.csrfToken || '';
+  appSessionToken = session.appSessionToken || '';
+  accessToken = session.accessToken || '';
+  refreshToken = session.refreshToken || '';
+  userSessionToken = session.userSessionToken || '';
+  otpToken = session.otpToken || '';
+}
+
+// ── Internals ───────────────────────────────────────────────────────
+
+function authHeaders() {
+  return { 'A-Sess': appSessionToken, 'U-Sess': userSessionToken };
+}
+
+function chargingHeaders() {
+  return { 'U-Sess': userSessionToken };
+}
+
+async function gql(url, body, extraHeaders = {}) {
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: {
+      ...BASE_HEADERS,
+      'dc-cid': `m-ios-${crypto.randomUUID()}`,
+      ...extraHeaders,
+    },
+    body: JSON.stringify(body),
+  });
+
+  const json = await res.json();
+
+  if (json.errors?.length) {
+    const e = json.errors[0];
+    const msg = e.message || e.extensions?.code || 'Unknown GraphQL error';
+    const err = new Error(msg);
+    err.code = e.extensions?.code;
+    err.reason = e.extensions?.reason;
+    throw err;
+  }
+
+  if (!res.ok) {
+    throw new Error(`HTTP ${res.status}`);
+  }
+
+  return json.data;
+}
+
+// ── Vehicle state property templates ────────────────────────────────
+
+const VALUE_TEMPLATE = '{ timeStamp value }';
+
+const TEMPLATE_MAP = {
+  cloudConnection: '{ lastSync isOnline }',
+  gnssLocation: '{ latitude longitude timeStamp isAuthorized }',
+  gnssError: '{ timeStamp positionVertical positionHorizontal speed bearing }',
+};
+
+const DEFAULT_VEHICLE_STATE_PROPERTIES = new Set([
+  'cloudConnection',
+  'gnssLocation',
+  'batteryLevel',
+  'batteryLimit',
+  'batteryCapacity',
+  'distanceToEmpty',
+  'vehicleMileage',
+  'powerState',
+  'chargerStatus',
+  'chargerState',
+  'chargePortState',
+  'otaAvailableVersion',
+  'otaAvailableVersionGitHash',
+  'otaCurrentVersion',
+  'otaCurrentVersionGitHash',
+  'otaStatus',
+  'otaInstallReady',
+  'otaInstallProgress',
+  'otaCurrentStatus',
+  'otaDownloadProgress',
+  'otaInstallType',
+  'driveMode',
+  'gearStatus',
+  'tirePressureStatusFrontLeft',
+  'tirePressureStatusFrontRight',
+  'tirePressureStatusRearLeft',
+  'tirePressureStatusRearRight',
+  'doorFrontLeftClosed',
+  'doorFrontRightClosed',
+  'doorRearLeftClosed',
+  'doorRearRightClosed',
+  'doorFrontLeftLocked',
+  'doorFrontRightLocked',
+  'doorRearLeftLocked',
+  'doorRearRightLocked',
+  'closureFrunkClosed',
+  'closureFrunkLocked',
+  'closureLiftgateClosed',
+  'closureLiftgateLocked',
+  'closureTailgateClosed',
+  'closureTailgateLocked',
+  'closureTonneauClosed',
+  'closureTonneauLocked',
+  'windowFrontLeftClosed',
+  'windowFrontRightClosed',
+  'windowRearLeftClosed',
+  'windowRearRightClosed',
+  'cabinClimateInteriorTemperature',
+  'cabinPreconditioningStatus',
+  'defrostDefogStatus',
+  'petModeStatus',
+  'gearGuardLocked',
+  'gearGuardVideoStatus',
+  'timeToEndOfCharge',
+  'remoteChargingAvailable',
+]);

package/mcp-server.js

@@ -0,0 +1,540 @@
+#!/usr/bin/env node
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, chmodSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import * as rivian from './lib/rivian.js';
+
+const CONFIG_DIR = join(homedir(), '.rivian-mcp');
+const SESSION_FILE = join(CONFIG_DIR, 'session.json');
+const SESSION_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+
+// ── Session persistence ───────────────────────────────────────────────
+
+function loadSession() {
+  if (!existsSync(SESSION_FILE)) return false;
+
+  try {
+    const st = statSync(SESSION_FILE);
+    if (st.mode & 0o077) {
+      console.error(
+        `[rivian-mcp] WARNING: ${SESSION_FILE} is readable by other users. Run: chmod 600 "${SESSION_FILE}"`,
+      );
+    }
+  } catch {}
+
+  const session = JSON.parse(readFileSync(SESSION_FILE, 'utf8'));
+
+  if (session.savedAt && Date.now() - session.savedAt > SESSION_MAX_AGE_MS) {
+    console.error('[rivian-mcp] Session expired. Please log in again.');
+    return false;
+  }
+
+  if (session.authenticated || session.needsOtp) {
+    rivian.restoreSession(session);
+    return session.authenticated ? true : 'needs_otp';
+  }
+
+  return false;
+}
+
+function saveSession() {
+  mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+  chmodSync(CONFIG_DIR, 0o700);
+  const session = { ...rivian.exportSession(), savedAt: Date.now() };
+  writeFileSync(SESSION_FILE, JSON.stringify(session, null, 2), { mode: 0o600 });
+  chmodSync(SESSION_FILE, 0o600);
+}
+
+function requireAuth() {
+  if (!rivian.isAuthenticated()) {
+    throw new Error('Not logged in. Ask the user to log in to Rivian first.');
+  }
+}
+
+function text(str) {
+  return { content: [{ type: 'text', text: str }] };
+}
+
+// ── Formatting ────────────────────────────────────────────────────────
+
+function formatUserInfo(user) {
+  const lines = [`${user.firstName} ${user.lastName} (${user.email})`, ''];
+
+  if (!user.vehicles?.length) {
+    lines.push('No vehicles on this account.');
+    return lines.join('\n');
+  }
+
+  for (const v of user.vehicles) {
+    const car = v.vehicle;
+    lines.push(v.name || car.model);
+    lines.push(`  ${car.modelYear} ${car.make} ${car.model}`);
+    lines.push(`  VIN: ${v.vin}`);
+    lines.push(`  Vehicle ID: ${v.id}`);
+
+    if (car.otaEarlyAccessStatus) {
+      lines.push(`  OTA early access: ${car.otaEarlyAccessStatus === 'OPTED_IN' ? 'Yes' : 'No'}`);
+    }
+    if (car.currentOTAUpdateDetails) {
+      lines.push(`  Software: v${car.currentOTAUpdateDetails.version}`);
+    }
+    if (car.availableOTAUpdateDetails) {
+      lines.push(`  Update available: v${car.availableOTAUpdateDetails.version}`);
+      lines.push(`  Release notes: ${car.availableOTAUpdateDetails.url}`);
+    } else {
+      lines.push('  Software is up to date');
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n').trim();
+}
+
+function formatVehicleState(state) {
+  const lines = [];
+  const printed = new Set();
+
+  function v(key) {
+    return state[key]?.value ?? null;
+  }
+
+  function print(label, key, suffix = '') {
+    if (!(key in state)) return;
+    printed.add(key);
+    const value = v(key);
+    if (value === null || value === undefined) return;
+    lines.push(`  ${label}: ${value}${suffix}`);
+  }
+
+  // Battery & Range
+  if ('batteryLevel' in state || 'distanceToEmpty' in state) {
+    lines.push('Battery & Range');
+    print('Battery', 'batteryLevel', '%');
+    print('Charge limit', 'batteryLimit', '%');
+    print('Capacity', 'batteryCapacity');
+    print('Range', 'distanceToEmpty', ' miles');
+    print('Odometer', 'vehicleMileage', ' miles');
+    print('Power', 'powerState');
+    print('Time to full', 'timeToEndOfCharge', ' min');
+    print('Remote charging', 'remoteChargingAvailable');
+    lines.push('');
+  }
+
+  // Charging
+  if ('chargerStatus' in state || 'chargerState' in state) {
+    lines.push('Charging');
+    print('Charger status', 'chargerStatus');
+    print('Charger state', 'chargerState');
+    print('Charge port', 'chargePortState');
+    lines.push('');
+  }
+
+  // Doors — combine closed + locked per door
+  const doorPositions = ['FrontLeft', 'FrontRight', 'RearLeft', 'RearRight'];
+  const doorLines = [];
+  for (const pos of doorPositions) {
+    const closedKey = `door${pos}Closed`;
+    const lockedKey = `door${pos}Locked`;
+    if (closedKey in state || lockedKey in state) {
+      printed.add(closedKey);
+      printed.add(lockedKey);
+      const parts = [v(closedKey), v(lockedKey)].filter(Boolean);
+      const label = pos.replace(/([A-Z])/g, ' $1').trim().toLowerCase();
+      if (parts.length) doorLines.push(`  ${label}: ${parts.join(', ')}`);
+    }
+  }
+  if (doorLines.length) {
+    lines.push('Doors');
+    lines.push(...doorLines);
+    lines.push('');
+  }
+
+  // Closures — frunk, liftgate, tailgate, tonneau
+  const closures = ['Frunk', 'Liftgate', 'Tailgate', 'Tonneau'];
+  const closureLines = [];
+  for (const name of closures) {
+    const closedKey = `closure${name}Closed`;
+    const lockedKey = `closure${name}Locked`;
+    if (closedKey in state || lockedKey in state) {
+      printed.add(closedKey);
+      printed.add(lockedKey);
+      const parts = [v(closedKey), v(lockedKey)].filter(Boolean);
+      if (parts.length) closureLines.push(`  ${name.toLowerCase()}: ${parts.join(', ')}`);
+    }
+  }
+  if (closureLines.length) {
+    lines.push('Closures');
+    lines.push(...closureLines);
+    lines.push('');
+  }
+
+  // Windows
+  const windowLines = [];
+  for (const pos of doorPositions) {
+    const key = `window${pos}Closed`;
+    if (key in state) {
+      printed.add(key);
+      const value = v(key);
+      if (value) {
+        const label = pos.replace(/([A-Z])/g, ' $1').trim().toLowerCase();
+        windowLines.push(`  ${label}: ${value}`);
+      }
+    }
+  }
+  if (windowLines.length) {
+    lines.push('Windows');
+    lines.push(...windowLines);
+    lines.push('');
+  }
+
+  // Climate
+  if ('cabinClimateInteriorTemperature' in state || 'cabinPreconditioningStatus' in state) {
+    lines.push('Climate');
+    if ('cabinClimateInteriorTemperature' in state) {
+      printed.add('cabinClimateInteriorTemperature');
+      const temp = v('cabinClimateInteriorTemperature');
+      if (temp) lines.push(`  Cabin temp: ${temp}°`);
+    }
+    print('Preconditioning', 'cabinPreconditioningStatus');
+    print('Defrost/defog', 'defrostDefogStatus');
+    print('Pet mode', 'petModeStatus');
+    lines.push('');
+  }
+
+  // Tires
+  const tirePositions = { FrontLeft: 'front left', FrontRight: 'front right', RearLeft: 'rear left', RearRight: 'rear right' };
+  const tireLines = [];
+  for (const [pos, label] of Object.entries(tirePositions)) {
+    const key = `tirePressureStatus${pos}`;
+    if (key in state) {
+      printed.add(key);
+      const value = v(key);
+      if (value) tireLines.push(`  ${label}: ${value}`);
+    }
+  }
+  if (tireLines.length) {
+    lines.push('Tire Pressure');
+    lines.push(...tireLines);
+    lines.push('');
+  }
+
+  // Software (OTA)
+  if ('otaCurrentVersion' in state || 'otaAvailableVersion' in state || 'otaStatus' in state) {
+    lines.push('Software');
+    print('Current version', 'otaCurrentVersion');
+    print('Available update', 'otaAvailableVersion');
+    print('Status', 'otaStatus');
+    print('Install status', 'otaCurrentStatus');
+    print('Install ready', 'otaInstallReady');
+    print('Install progress', 'otaInstallProgress', '%');
+    print('Download progress', 'otaDownloadProgress', '%');
+    print('Install type', 'otaInstallType');
+    print('Current hash', 'otaCurrentVersionGitHash');
+    print('Available hash', 'otaAvailableVersionGitHash');
+    lines.push('');
+  }
+
+  // Security
+  if ('gearGuardLocked' in state) {
+    lines.push('Security');
+    print('Gear Guard', 'gearGuardLocked');
+    print('Gear Guard video', 'gearGuardVideoStatus');
+    lines.push('');
+  }
+
+  // Drive
+  if ('driveMode' in state || 'gearStatus' in state) {
+    lines.push('Drive');
+    print('Drive mode', 'driveMode');
+    print('Gear', 'gearStatus');
+    lines.push('');
+  }
+
+  // Connection
+  if ('cloudConnection' in state) {
+    printed.add('cloudConnection');
+    const cc = state.cloudConnection;
+    const online = cc?.isOnline ? 'Online' : 'Offline';
+    const sync = cc?.lastSync ? ` (last sync: ${cc.lastSync})` : '';
+    lines.push('Connection');
+    lines.push(`  Status: ${online}${sync}`);
+    lines.push('');
+  }
+
+  // Location
+  if ('gnssLocation' in state) {
+    printed.add('gnssLocation');
+    const loc = state.gnssLocation;
+    if (loc?.latitude && loc?.longitude) {
+      lines.push('Location');
+      lines.push(`  ${loc.latitude}, ${loc.longitude}`);
+      lines.push('');
+    }
+  }
+
+  // Anything not already printed
+  const remaining = [];
+  for (const [key, entry] of Object.entries(state)) {
+    if (printed.has(key)) continue;
+    const value = entry?.value ?? entry;
+    if (value !== null && value !== undefined) {
+      remaining.push(`  ${key}: ${value}`);
+    }
+  }
+  if (remaining.length) {
+    lines.push('Other');
+    lines.push(...remaining);
+  }
+
+  return lines.join('\n').trim();
+}
+
+function formatOTAStatus(ota) {
+  const lines = [];
+
+  if (ota.currentOTAUpdateDetails) {
+    lines.push(`Current software: v${ota.currentOTAUpdateDetails.version}`);
+  } else {
+    lines.push('Current software: unknown');
+  }
+
+  if (ota.availableOTAUpdateDetails) {
+    lines.push(`Update available: v${ota.availableOTAUpdateDetails.version}`);
+    if (ota.availableOTAUpdateDetails.url) {
+      lines.push(`Release notes: ${ota.availableOTAUpdateDetails.url}`);
+    }
+  } else {
+    lines.push('No update available — software is up to date.');
+  }
+
+  return lines.join('\n');
+}
+
+function formatChargingSession(data) {
+  if (!data) return 'No active charging session.';
+
+  const lines = ['Charging Session'];
+
+  const add = (label, entry, suffix = '') => {
+    const value = entry?.value;
+    if (value !== undefined && value !== null) lines.push(`  ${label}: ${value}${suffix}`);
+  };
+
+  add('Battery', data.soc, '%');
+  add('Power', data.power, ' kW');
+  add('Range added', data.rangeAddedThisSession, ' miles');
+  add('Energy charged', data.totalChargedEnergy, ' kWh');
+  add('Current', data.current, ' A');
+  if (data.timeElapsed) lines.push(`  Time elapsed: ${data.timeElapsed}`);
+  add('Time remaining', data.timeRemaining, ' min');
+
+  if (data.isRivianCharger) lines.push('  Network: Rivian Adventure Network');
+  if (data.isFreeSession) {
+    lines.push('  Cost: Free');
+  } else if (data.currentPrice) {
+    lines.push(`  Cost so far: ${data.currentCurrency || '$'}${data.currentPrice}`);
+  }
+
+  add('Charger state', data.vehicleChargerState);
+
+  return lines.join('\n');
+}
+
+function formatDriversAndKeys(data) {
+  const lines = [];
+
+  if (data.vin) lines.push(`Vehicle: ${data.vin}`);
+
+  if (!data.invitedUsers?.length) {
+    lines.push('No drivers or keys found.');
+    return lines.join('\n');
+  }
+
+  lines.push('');
+  for (const user of data.invitedUsers) {
+    if (user.firstName) {
+      lines.push(`${user.firstName} ${user.lastName} (${user.email})`);
+      if (user.roles?.length) lines.push(`  Roles: ${user.roles.join(', ')}`);
+
+      if (user.devices?.length) {
+        for (const d of user.devices) {
+          const name = d.deviceName || d.type;
+          const status = [
+            d.isPaired ? 'paired' : 'not paired',
+            d.isEnabled ? 'enabled' : 'disabled',
+          ].join(', ');
+          lines.push(`  ${name} — ${status}`);
+        }
+      }
+    } else {
+      lines.push(`${user.email} (invited, ${user.status})`);
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n').trim();
+}
+
+// ── Restore session on startup ────────────────────────────────────────
+
+loadSession();
+
+// ── MCP Server ────────────────────────────────────────────────────────
+
+const server = new McpServer({
+  name: 'rivian',
+  version: '1.0.0',
+});
+
+// ── Auth tools ────────────────────────────────────────────────────────
+
+server.tool(
+  'rivian_login',
+  'Log in to your Rivian account. Rivian will send a verification code to your phone or email — use rivian_submit_otp to complete sign-in.',
+  {},
+  async () => {
+    const email = process.env.RIVIAN_EMAIL;
+    const password = process.env.RIVIAN_PASSWORD;
+    if (!email || !password) {
+      return text(
+        'Rivian credentials are not configured. Set RIVIAN_EMAIL and RIVIAN_PASSWORD in your MCP server settings.',
+      );
+    }
+
+    try {
+      await rivian.createCsrfToken();
+      const { mfa } = await rivian.login(email, password);
+      saveSession();
+
+      if (mfa) {
+        return text(
+          "A verification code has been sent to your phone or email. Tell me the code and I'll complete the sign-in.",
+        );
+      }
+
+      return text('Signed in to Rivian successfully.');
+    } catch (err) {
+      return text(`Couldn't sign in: ${err.message}`);
+    }
+  },
+);
+
+server.tool(
+  'rivian_submit_otp',
+  'Complete Rivian sign-in with the verification code sent to your phone or email.',
+  { otp_code: z.string().describe('The verification code') },
+  async ({ otp_code }) => {
+    const email = process.env.RIVIAN_EMAIL;
+    if (!email) {
+      return text('RIVIAN_EMAIL is not configured.');
+    }
+
+    if (!rivian.needsOtp()) {
+      return text('No pending verification. Start with rivian_login first.');
+    }
+
+    try {
+      await rivian.validateOtp(email, otp_code);
+      saveSession();
+      return text('Signed in to Rivian successfully.');
+    } catch (err) {
+      return text(
+        `Verification failed: ${err.message}. You may need to start over with rivian_login.`,
+      );
+    }
+  },
+);
+
+// ── Read-only query tools ─────────────────────────────────────────────
+
+server.tool(
+  'rivian_get_user_info',
+  'Look up your Rivian account — your vehicles, software versions, and account details.',
+  {},
+  async () => {
+    try {
+      requireAuth();
+      return text(formatUserInfo(await rivian.getUserInfo()));
+    } catch (err) {
+      return text(err.message);
+    }
+  },
+);
+
+server.tool(
+  'rivian_get_vehicle_state',
+  "Check your vehicle's current status — battery, range, doors, tires, location, climate, software, and more.",
+  {
+    vehicle_id: z.string().describe('Vehicle ID from your account info'),
+    properties: z
+      .array(z.string())
+      .optional()
+      .describe('Specific properties to check. Leave empty for a full status report.'),
+  },
+  async ({ vehicle_id, properties }) => {
+    try {
+      requireAuth();
+      const props = properties ? new Set(properties) : undefined;
+      return text(formatVehicleState(await rivian.getVehicleState(vehicle_id, props)));
+    } catch (err) {
+      return text(err.message);
+    }
+  },
+);
+
+server.tool(
+  'rivian_get_ota_status',
+  "Check for software updates — what version you're running and whether a new one is available.",
+  {
+    vehicle_id: z.string().describe('Vehicle ID from your account info'),
+  },
+  async ({ vehicle_id }) => {
+    try {
+      requireAuth();
+      return text(formatOTAStatus(await rivian.getOTAUpdateDetails(vehicle_id)));
+    } catch (err) {
+      return text(err.message);
+    }
+  },
+);
+
+server.tool(
+  'rivian_get_charging_session',
+  'Check on an active charging session — power, battery level, time remaining, and cost.',
+  {
+    vehicle_id: z.string().describe('Vehicle ID from your account info'),
+  },
+  async ({ vehicle_id }) => {
+    try {
+      requireAuth();
+      return text(formatChargingSession(await rivian.getLiveChargingSession(vehicle_id)));
+    } catch (err) {
+      return text(err.message);
+    }
+  },
+);
+
+server.tool(
+  'rivian_get_drivers_and_keys',
+  'See who has access to your vehicle — drivers, phone keys, and key fobs.',
+  {
+    vehicle_id: z.string().describe('Vehicle ID from your account info'),
+  },
+  async ({ vehicle_id }) => {
+    try {
+      requireAuth();
+      return text(formatDriversAndKeys(await rivian.getDriversAndKeys(vehicle_id)));
+    } catch (err) {
+      return text(err.message);
+    }
+  },
+);
+
+// ── Start ─────────────────────────────────────────────────────────────
+
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "rivian-mcp",
+  "version": "1.0.0",
+  "description": "Read-only MCP server for the Rivian API — vehicle state, OTA status, charging, and more",
+  "type": "module",
+  "bin": {
+    "rivian-mcp": "mcp-server.js"
+  },
+  "main": "mcp-server.js",
+  "files": [
+    "mcp-server.js",
+    "lib/"
+  ],
+  "scripts": {
+    "start": "node mcp-server.js"
+  },
+  "keywords": [
+    "rivian",
+    "mcp",
+    "ev",
+    "vehicle",
+    "api"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/PatrickHeneise/rivian-mcp.git"
+  },
+  "homepage": "https://github.com/PatrickHeneise/rivian-mcp#readme",
+  "bugs": {
+    "url": "https://github.com/PatrickHeneise/rivian-mcp/issues"
+  },
+  "author": "Patrick Heneise",
+  "license": "MIT",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "tag": "latest",
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "semantic-release": "^25.0.3"
+  }
+}