@oceanswave/openclaw-tescmd 0.3.1

package/tools/charge.ts

@@ -0,0 +1,141 @@
+/**
+ * Charging tools — status, start, stop, and set limit.
+ *
+ * Control and monitor the vehicle's charging state via the tescmd node.
+ * Write commands auto-wake the vehicle if it's asleep and invalidate
+ * the response cache on success.
+ */
+
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+
+export function registerChargeTools(api: OpenClawPluginApi): void {
+	// -----------------------------------------------------------------
+	// tescmd_get_charge_state
+	// -----------------------------------------------------------------
+	api.registerTool(
+		{
+			name: "tescmd_get_charge_state",
+			label: "Get Charge State",
+			description:
+				"Get the Tesla vehicle's current charging status. Returns {charge_state} " +
+				"as a string: 'Charging', 'Complete', 'Stopped', 'Disconnected', 'Starting', etc. " +
+				"\n\nWhen to use: User asks 'is the car charging?', you need to check before " +
+				"starting/stopping a charge, or for a full vehicle status report. Pair with " +
+				"tescmd_get_battery for a complete charging picture (state + level + range). " +
+				"\n\nData source: ChargeState/DetailedChargeState telemetry → Fleet API charge_state.",
+			parameters: Type.Object({}),
+			async execute(_toolCallId: string, _params: Record<string, unknown>) {
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text: "Invoking charge_state.get on tescmd node",
+						},
+					],
+					details: { nodeMethod: "charge_state.get", params: {} },
+				};
+			},
+		},
+		{ name: "tescmd_get_charge_state" },
+	);
+
+	// -----------------------------------------------------------------
+	// tescmd_start_charge
+	// -----------------------------------------------------------------
+	api.registerTool(
+		{
+			name: "tescmd_start_charge",
+			label: "Start Charging",
+			description:
+				"Start charging the Tesla vehicle. The charge cable must already be " +
+				"connected. Auto-wakes the vehicle if asleep (billable API call). " +
+				"Returns {result: true, reason: 'ok'} on success. " +
+				"\n\nWhen to use: User says 'start charging', 'plug in and charge', or you've " +
+				"checked tescmd_get_charge_state and it shows 'Stopped' or 'Disconnected' while " +
+				"the user wants to charge. Check charge_state first to confirm the cable is connected. " +
+				"\n\nWorkflow: tescmd_get_charge_state → verify connected → tescmd_start_charge → " +
+				"optionally tescmd_set_charge_limit if user specified a target.",
+			parameters: Type.Object({}),
+			async execute(_toolCallId: string, _params: Record<string, unknown>) {
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text: "Invoking charge.start on tescmd node",
+						},
+					],
+					details: { nodeMethod: "charge.start", params: {} },
+				};
+			},
+		},
+		{ name: "tescmd_start_charge" },
+	);
+
+	// -----------------------------------------------------------------
+	// tescmd_stop_charge
+	// -----------------------------------------------------------------
+	api.registerTool(
+		{
+			name: "tescmd_stop_charge",
+			label: "Stop Charging",
+			description:
+				"Stop an active charging session on the Tesla vehicle. " +
+				"Returns {result: true, reason: 'ok'} on success. " +
+				"Has no effect if the vehicle is not currently charging.",
+			parameters: Type.Object({}),
+			async execute(_toolCallId: string, _params: Record<string, unknown>) {
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text: "Invoking charge.stop on tescmd node",
+						},
+					],
+					details: { nodeMethod: "charge.stop", params: {} },
+				};
+			},
+		},
+		{ name: "tescmd_stop_charge" },
+	);
+
+	// -----------------------------------------------------------------
+	// tescmd_set_charge_limit
+	// -----------------------------------------------------------------
+	api.registerTool(
+		{
+			name: "tescmd_set_charge_limit",
+			label: "Set Charge Limit",
+			description:
+				"Set the Tesla vehicle's battery charge limit as a percentage (50-100). " +
+				"The vehicle will stop charging when it reaches this level. " +
+				"Returns {result: true, reason: 'ok'} on success. " +
+				"\n\nWhen to use: User says 'charge to 80%', 'set limit to 90 for my trip', " +
+				"or as part of a charging workflow. Tesla recommends 80% for daily use and " +
+				"100% only before long trips. " +
+				"\n\nWorkflow: Often used with tescmd_start_charge — set the limit first, then start.",
+			parameters: Type.Object({
+				percent: Type.Number({
+					description: "Charge limit percentage (50-100)",
+					minimum: 50,
+					maximum: 100,
+				}),
+			}),
+			async execute(_toolCallId: string, params: Record<string, unknown>) {
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text: `Invoking charge.set_limit with percent=${params.percent} on tescmd node`,
+						},
+					],
+					details: {
+						nodeMethod: "charge.set_limit",
+						params: { percent: params.percent },
+					},
+				};
+			},
+		},
+		{ name: "tescmd_set_charge_limit" },
+	);
+}

package/tools/climate.ts

@@ -0,0 +1,134 @@
+/**
+ * Climate control tools — temperature reading, HVAC on/off, and temp setting.
+ *
+ * Control and monitor the vehicle's climate system via the tescmd node.
+ */
+
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+
+export function registerClimateTools(api: OpenClawPluginApi): void {
+	// -----------------------------------------------------------------
+	// tescmd_get_temperature
+	// -----------------------------------------------------------------
+	api.registerTool(
+		{
+			name: "tescmd_get_temperature",
+			label: "Get Temperature",
+			description:
+				"Get the Tesla vehicle's inside cabin and outside ambient temperatures " +
+				"in Celsius. Returns {inside_temp_c, outside_temp_c}. " +
+				"\n\nWhen to use: User asks about temperature, asks 'is the car hot/cold?', " +
+				"or you need to decide whether to suggest preconditioning. Check this before " +
+				"turning on climate to give the user context ('cabin is currently 95°F, starting climate'). " +
+				"\n\nWorkflow: tescmd_get_temperature → decide → tescmd_climate_on + tescmd_set_climate_temp. " +
+				"\n\nData source: InsideTemp/OutsideTemp telemetry → Fleet API climate_state.",
+			parameters: Type.Object({}),
+			async execute(_toolCallId: string, _params: Record<string, unknown>) {
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text: "Invoking temperature.get on tescmd node",
+						},
+					],
+					details: { nodeMethod: "temperature.get", params: {} },
+				};
+			},
+		},
+		{ name: "tescmd_get_temperature" },
+	);
+
+	// -----------------------------------------------------------------
+	// tescmd_climate_on
+	// -----------------------------------------------------------------
+	api.registerTool(
+		{
+			name: "tescmd_climate_on",
+			label: "Turn Climate On",
+			description:
+				"Turn on the Tesla vehicle's climate control (HVAC). Starts " +
+				"auto-conditioning at the previously set temperature. Auto-wakes if asleep. " +
+				"\n\nWhen to use: User says 'cool down/warm up the car', 'start climate', " +
+				"'precondition the cabin', or temperature check shows uncomfortable temps. " +
+				"Often paired with tescmd_set_climate_temp if the user specifies a target. " +
+				"\n\nWorkflow: tescmd_get_temperature → tescmd_climate_on → tescmd_set_climate_temp (optional).",
+			parameters: Type.Object({}),
+			async execute(_toolCallId: string, _params: Record<string, unknown>) {
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text: "Invoking climate.on on tescmd node",
+						},
+					],
+					details: { nodeMethod: "climate.on", params: {} },
+				};
+			},
+		},
+		{ name: "tescmd_climate_on" },
+	);
+
+	// -----------------------------------------------------------------
+	// tescmd_climate_off
+	// -----------------------------------------------------------------
+	api.registerTool(
+		{
+			name: "tescmd_climate_off",
+			label: "Turn Climate Off",
+			description:
+				"Turn off the Tesla vehicle's climate control (HVAC). Stops " +
+				"auto-conditioning. Returns {result: true, reason: 'ok'} on success.",
+			parameters: Type.Object({}),
+			async execute(_toolCallId: string, _params: Record<string, unknown>) {
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text: "Invoking climate.off on tescmd node",
+						},
+					],
+					details: { nodeMethod: "climate.off", params: {} },
+				};
+			},
+		},
+		{ name: "tescmd_climate_off" },
+	);
+
+	// -----------------------------------------------------------------
+	// tescmd_set_climate_temp
+	// -----------------------------------------------------------------
+	api.registerTool(
+		{
+			name: "tescmd_set_climate_temp",
+			label: "Set Climate Temperature",
+			description:
+				"Set the Tesla vehicle's cabin temperature for climate control in Fahrenheit. " +
+				"Sets both driver and passenger zones to the same temperature. " +
+				"Climate must be on (tescmd_climate_on) for the setting to take effect. " +
+				"\n\nWhen to use: User says 'set the car to 72 degrees', 'make it warmer/cooler'. " +
+				"If climate isn't already on, call tescmd_climate_on first, then set temp. " +
+				"\n\nCommon range: 60-85°F. Note: this takes Fahrenheit, not Celsius.",
+			parameters: Type.Object({
+				temp: Type.Number({
+					description: "Desired cabin temperature in Fahrenheit (e.g. 72)",
+				}),
+			}),
+			async execute(_toolCallId: string, params: Record<string, unknown>) {
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text: `Invoking climate.set_temp with temp=${params.temp}°F on tescmd node`,
+						},
+					],
+					details: {
+						nodeMethod: "climate.set_temp",
+						params: { temp: params.temp },
+					},
+				};
+			},
+		},
+		{ name: "tescmd_set_climate_temp" },
+	);
+}

package/tools/navigation.ts

@@ -0,0 +1,199 @@
+/**
+ * Navigation tools — send destinations, GPS coordinates, and trigger HomeLink.
+ *
+ * All navigation commands target the vehicle's infotainment system and use
+ * signed commands via the Vehicle Command Protocol when available.  The
+ * vehicle must be awake to receive navigation requests.
+ */
+
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+
+export function registerNavigationTools(api: OpenClawPluginApi): void {
+	// -----------------------------------------------------------------
+	// tescmd_nav_send
+	// -----------------------------------------------------------------
+	api.registerTool(
+		{
+			name: "tescmd_nav_send",
+			label: "Send Destination",
+			description:
+				"Send a street address or place name to the Tesla vehicle's navigation. " +
+				"The destination appears on the vehicle's touchscreen, ready to start routing. " +
+				"Auto-wakes the vehicle if asleep. " +
+				"\n\nWhen to use: User says 'navigate to [place]', 'send directions to the car', " +
+				"or 'set the destination to [address]'. Pass the full address string. " +
+				"\n\nAlias: Tesla Fleet API 'share' command.",
+			parameters: Type.Object({
+				address: Type.String({
+					description:
+						"Full street address or place name (e.g. '1600 Amphitheatre Parkway, Mountain View, CA')",
+				}),
+			}),
+			async execute(_toolCallId: string, params: Record<string, unknown>) {
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text: `Sending destination: ${params.address}`,
+						},
+					],
+					details: {
+						nodeMethod: "nav.send",
+						params: { address: params.address },
+					},
+				};
+			},
+		},
+		{ name: "tescmd_nav_send" },
+	);
+
+	// -----------------------------------------------------------------
+	// tescmd_nav_gps
+	// -----------------------------------------------------------------
+	api.registerTool(
+		{
+			name: "tescmd_nav_gps",
+			label: "Navigate to GPS Coordinates",
+			description:
+				"Send GPS coordinates to the Tesla vehicle's navigation. The vehicle will " +
+				"display the location and be ready to start routing. Useful when you have " +
+				"exact coordinates rather than a street address. Auto-wakes the vehicle. " +
+				"\n\nWhen to use: User provides lat/lon coordinates, or you've obtained " +
+				"coordinates from a location lookup. Optionally set 'order' for multi-stop trips.",
+			parameters: Type.Object({
+				lat: Type.Number({ description: "Latitude in decimal degrees" }),
+				lon: Type.Number({ description: "Longitude in decimal degrees" }),
+				order: Type.Optional(
+					Type.Number({
+						description: "Waypoint order for multi-stop navigation (0-based)",
+					}),
+				),
+			}),
+			async execute(_toolCallId: string, params: Record<string, unknown>) {
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text: `Navigating to GPS: ${params.lat}, ${params.lon}`,
+						},
+					],
+					details: {
+						nodeMethod: "nav.gps",
+						params: {
+							lat: params.lat,
+							lon: params.lon,
+							...(params.order != null ? { order: params.order } : {}),
+						},
+					},
+				};
+			},
+		},
+		{ name: "tescmd_nav_gps" },
+	);
+
+	// -----------------------------------------------------------------
+	// tescmd_nav_supercharger
+	// -----------------------------------------------------------------
+	api.registerTool(
+		{
+			name: "tescmd_nav_supercharger",
+			label: "Navigate to Supercharger",
+			description:
+				"Send the vehicle to the nearest Tesla Supercharger. The vehicle's " +
+				"navigation will route to the closest available Supercharger station. " +
+				"Auto-wakes the vehicle. " +
+				"\n\nWhen to use: User says 'find a Supercharger', 'I need to charge', " +
+				"or battery is low and no home charger is available. Pair with " +
+				"tescmd_get_battery to check if charging is actually needed first.",
+			parameters: Type.Object({}),
+			async execute(_toolCallId: string, _params: Record<string, unknown>) {
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text: "Navigating to nearest Supercharger",
+						},
+					],
+					details: { nodeMethod: "nav.supercharger", params: {} },
+				};
+			},
+		},
+		{ name: "tescmd_nav_supercharger" },
+	);
+
+	// -----------------------------------------------------------------
+	// tescmd_nav_waypoints
+	// -----------------------------------------------------------------
+	api.registerTool(
+		{
+			name: "tescmd_nav_waypoints",
+			label: "Send Multi-Stop Waypoints",
+			description:
+				"Send a multi-stop route to the Tesla vehicle using waypoints. " +
+				"Waypoints are specified as a comma-separated string of encoded " +
+				"reference IDs (Google Place IDs in refId format). The vehicle will " +
+				"create a multi-stop route through all waypoints in order. " +
+				"\n\nWhen to use: User wants a road trip with multiple stops, " +
+				"or needs to plan a route through several destinations.",
+			parameters: Type.Object({
+				waypoints: Type.String({
+					description: "Comma-separated waypoint reference IDs (Google Place IDs in refId format)",
+				}),
+			}),
+			async execute(_toolCallId: string, params: Record<string, unknown>) {
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text: `Sending waypoints: ${params.waypoints}`,
+						},
+					],
+					details: {
+						nodeMethod: "nav.waypoints",
+						params: { waypoints: params.waypoints },
+					},
+				};
+			},
+		},
+		{ name: "tescmd_nav_waypoints" },
+	);
+
+	// -----------------------------------------------------------------
+	// tescmd_homelink
+	// -----------------------------------------------------------------
+	api.registerTool(
+		{
+			name: "tescmd_homelink",
+			label: "Trigger HomeLink",
+			description:
+				"Trigger the vehicle's HomeLink to open or close a garage door. " +
+				"Requires the vehicle's current GPS coordinates (lat/lon) to verify " +
+				"the vehicle is within range of the programmed HomeLink device. " +
+				"Auto-wakes the vehicle. " +
+				"\n\nWhen to use: User says 'open the garage', 'trigger HomeLink', " +
+				"or 'open the garage door'. Get the vehicle's location first with " +
+				"tescmd_get_location to provide the lat/lon coordinates. " +
+				"\n\nWorkflow: tescmd_get_location → extract lat/lon → tescmd_homelink.",
+			parameters: Type.Object({
+				lat: Type.Number({ description: "Vehicle's current latitude" }),
+				lon: Type.Number({ description: "Vehicle's current longitude" }),
+			}),
+			async execute(_toolCallId: string, params: Record<string, unknown>) {
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text: "Triggering HomeLink",
+						},
+					],
+					details: {
+						nodeMethod: "homelink.trigger",
+						params: { lat: params.lat, lon: params.lon },
+					},
+				};
+			},
+		},
+		{ name: "tescmd_homelink" },
+	);
+}

package/tools/security.ts

@@ -0,0 +1,207 @@
+/**
+ * Security tools — lock state, door lock/unlock, flash, honk, sentry mode.
+ *
+ * Control and monitor the vehicle's security features via the tescmd node.
+ * All write commands auto-wake the vehicle if asleep.
+ */
+
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+
+export function registerSecurityTools(api: OpenClawPluginApi): void {
+	// -----------------------------------------------------------------
+	// tescmd_get_security
+	// -----------------------------------------------------------------
+	api.registerTool(
+		{
+			name: "tescmd_get_security",
+			label: "Get Security Status",
+			description:
+				"Get the Tesla vehicle's security status: whether doors are locked " +
+				"and whether Sentry Mode is active. Returns {locked: boolean, sentry_mode: boolean}. " +
+				"\n\nWhen to use: User asks 'is my car locked?', 'is sentry on?', part of a " +
+				"'vehicle status' overview, or before deciding whether to lock/enable sentry. " +
+				"\n\nData source: Locked/SentryMode telemetry → Fleet API vehicle_state.",
+			parameters: Type.Object({}),
+			async execute(_toolCallId: string, _params: Record<string, unknown>) {
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text: "Invoking security.get on tescmd node",
+						},
+					],
+					details: { nodeMethod: "security.get", params: {} },
+				};
+			},
+		},
+		{ name: "tescmd_get_security" },
+	);
+
+	// -----------------------------------------------------------------
+	// tescmd_lock_doors
+	// -----------------------------------------------------------------
+	api.registerTool(
+		{
+			name: "tescmd_lock_doors",
+			label: "Lock Doors",
+			description:
+				"Lock all doors on the Tesla vehicle. Uses the VCSEC (Vehicle " +
+				"Security) command domain with signed commands when available. " +
+				"Auto-wakes the vehicle if asleep. Returns {result: true, reason: 'ok'}.",
+			parameters: Type.Object({}),
+			async execute(_toolCallId: string, _params: Record<string, unknown>) {
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text: "Invoking door.lock on tescmd node",
+						},
+					],
+					details: { nodeMethod: "door.lock", params: {} },
+				};
+			},
+		},
+		{ name: "tescmd_lock_doors" },
+	);
+
+	// -----------------------------------------------------------------
+	// tescmd_unlock_doors
+	// -----------------------------------------------------------------
+	api.registerTool(
+		{
+			name: "tescmd_unlock_doors",
+			label: "Unlock Doors",
+			description:
+				"Unlock all doors on the Tesla vehicle. Uses signed VCSEC commands " +
+				"when available. Auto-wakes if asleep. Returns {result: true, reason: 'ok'}. " +
+				"\n\nWhen to use: User explicitly asks to unlock. IMPORTANT: This grants " +
+				"physical access to the vehicle — always confirm the user's intent before " +
+				"unlocking. Never unlock proactively or as part of an automated workflow " +
+				"without explicit user confirmation.",
+			parameters: Type.Object({}),
+			async execute(_toolCallId: string, _params: Record<string, unknown>) {
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text: "Invoking door.unlock on tescmd node",
+						},
+					],
+					details: { nodeMethod: "door.unlock", params: {} },
+				};
+			},
+		},
+		{ name: "tescmd_unlock_doors" },
+	);
+
+	// -----------------------------------------------------------------
+	// tescmd_flash_lights
+	// -----------------------------------------------------------------
+	api.registerTool(
+		{
+			name: "tescmd_flash_lights",
+			label: "Flash Lights",
+			description:
+				"Flash the Tesla vehicle's headlights briefly. Useful for " +
+				"locating the vehicle in a parking lot or signaling. " +
+				"Auto-wakes the vehicle if asleep.",
+			parameters: Type.Object({}),
+			async execute(_toolCallId: string, _params: Record<string, unknown>) {
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text: "Invoking flash_lights on tescmd node",
+						},
+					],
+					details: { nodeMethod: "flash_lights", params: {} },
+				};
+			},
+		},
+		{ name: "tescmd_flash_lights" },
+	);
+
+	// -----------------------------------------------------------------
+	// tescmd_honk_horn
+	// -----------------------------------------------------------------
+	api.registerTool(
+		{
+			name: "tescmd_honk_horn",
+			label: "Honk Horn",
+			description:
+				"Honk the Tesla vehicle's horn briefly. Useful for locating " +
+				"the vehicle or alerting nearby people. Auto-wakes the vehicle if asleep.",
+			parameters: Type.Object({}),
+			async execute(_toolCallId: string, _params: Record<string, unknown>) {
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text: "Invoking honk_horn on tescmd node",
+						},
+					],
+					details: { nodeMethod: "honk_horn", params: {} },
+				};
+			},
+		},
+		{ name: "tescmd_honk_horn" },
+	);
+
+	// -----------------------------------------------------------------
+	// tescmd_sentry_on
+	// -----------------------------------------------------------------
+	api.registerTool(
+		{
+			name: "tescmd_sentry_on",
+			label: "Enable Sentry Mode",
+			description:
+				"Enable Sentry Mode on the Tesla vehicle. When active, cameras monitor " +
+				"surroundings and record events on potential threats (people approaching, " +
+				"door attempts, etc.). Uses ~1-2% battery per hour. " +
+				"\n\nWhen to use: User says 'turn on sentry', 'watch the car', or as part of " +
+				"a parking security workflow. Consider warning about battery impact if the " +
+				"car has low charge. " +
+				"\n\nWorkflow: tescmd_lock_doors → tescmd_sentry_on → optionally tescmd_location_trigger (geofence).",
+			parameters: Type.Object({}),
+			async execute(_toolCallId: string, _params: Record<string, unknown>) {
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text: "Invoking sentry.on on tescmd node",
+						},
+					],
+					details: { nodeMethod: "sentry.on", params: {} },
+				};
+			},
+		},
+		{ name: "tescmd_sentry_on" },
+	);
+
+	// -----------------------------------------------------------------
+	// tescmd_sentry_off
+	// -----------------------------------------------------------------
+	api.registerTool(
+		{
+			name: "tescmd_sentry_off",
+			label: "Disable Sentry Mode",
+			description:
+				"Disable Sentry Mode on the Tesla vehicle. Stops camera monitoring " +
+				"and reduces battery drain. Returns {result: true, reason: 'ok'}.",
+			parameters: Type.Object({}),
+			async execute(_toolCallId: string, _params: Record<string, unknown>) {
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text: "Invoking sentry.off on tescmd node",
+						},
+					],
+					details: { nodeMethod: "sentry.off", params: {} },
+				};
+			},
+		},
+		{ name: "tescmd_sentry_off" },
+	);
+}