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

tescmd/triggers/__init__.py

@@ -0,0 +1,18 @@
+"""Trigger/subscription system for telemetry-driven notifications."""
+
+from tescmd.triggers.manager import TriggerLimitError, TriggerManager
+from tescmd.triggers.models import (
+    TriggerCondition,
+    TriggerDefinition,
+    TriggerNotification,
+    TriggerOperator,
+)
+
+__all__ = [
+    "TriggerCondition",
+    "TriggerDefinition",
+    "TriggerLimitError",
+    "TriggerManager",
+    "TriggerNotification",
+    "TriggerOperator",
+]

tescmd/triggers/manager.py

@@ -0,0 +1,264 @@
+"""Trigger evaluation engine.
+
+Evaluates registered triggers against incoming telemetry values,
+manages cooldowns, fires callbacks, and queues notifications.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from collections import defaultdict, deque
+from typing import TYPE_CHECKING, Any
+
+from tescmd.triggers.models import (
+    TriggerCondition,
+    TriggerDefinition,
+    TriggerNotification,
+    TriggerOperator,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
+    from datetime import datetime
+
+logger = logging.getLogger(__name__)
+
+MAX_TRIGGERS = 100
+MAX_PENDING = 500
+
+
+class TriggerLimitError(Exception):
+    """Raised when the maximum number of triggers is exceeded."""
+
+
+class TriggerManager:
+    """Manages trigger lifecycle and evaluation.
+
+    Parameters
+    ----------
+    vin:
+        Vehicle Identification Number — included in notifications.
+    """
+
+    def __init__(self, vin: str) -> None:
+        self._vin = vin
+        self._triggers: dict[str, TriggerDefinition] = {}
+        self._field_index: dict[str, set[str]] = defaultdict(set)
+        self._last_fire_times: dict[str, float] = {}
+        self._pending: deque[TriggerNotification] = deque(maxlen=MAX_PENDING)
+        self._on_fire_callbacks: list[Callable[[TriggerNotification], Awaitable[None]]] = []
+
+    def create(self, trigger: TriggerDefinition) -> TriggerDefinition:
+        """Register a trigger.  Returns the trigger with its assigned ID.
+
+        Raises :class:`TriggerLimitError` if the limit is reached.
+        """
+        if len(self._triggers) >= MAX_TRIGGERS:
+            raise TriggerLimitError(
+                f"Maximum of {MAX_TRIGGERS} triggers reached. "
+                "Delete some before creating new ones."
+            )
+
+        cond = trigger.condition
+        self._triggers[trigger.id] = trigger
+        self._field_index[cond.field].add(trigger.id)
+        logger.info(
+            "Created trigger %s: %s %s %s",
+            trigger.id,
+            cond.field,
+            cond.operator.value,
+            cond.value,
+        )
+        return trigger
+
+    def delete(self, trigger_id: str) -> bool:
+        """Remove a trigger by ID.  Returns ``True`` if it existed."""
+        trigger = self._triggers.pop(trigger_id, None)
+        if trigger is None:
+            return False
+        field = trigger.condition.field
+        ids = self._field_index.get(field)
+        if ids is not None:
+            ids.discard(trigger_id)
+            if not ids:
+                del self._field_index[field]
+        self._last_fire_times.pop(trigger_id, None)
+        logger.info("Deleted trigger %s", trigger_id)
+        return True
+
+    def list_all(self) -> list[TriggerDefinition]:
+        """Return all registered triggers."""
+        return list(self._triggers.values())
+
+    def drain_pending(self) -> list[TriggerNotification]:
+        """Return and clear all pending notifications (for MCP polling)."""
+        result = list(self._pending)
+        self._pending.clear()
+        return result
+
+    def add_on_fire(self, callback: Callable[[TriggerNotification], Awaitable[None]]) -> None:
+        """Register an async callback invoked when a trigger fires."""
+        self._on_fire_callbacks.append(callback)
+
+    async def evaluate(
+        self,
+        field: str,
+        value: Any,
+        previous_value: Any,
+        timestamp: datetime,
+    ) -> None:
+        """Evaluate all triggers registered for *field*.
+
+        Called by the bridge after capturing the previous value and
+        before updating the telemetry store.
+        """
+        trigger_ids = self._field_index.get(field)
+        if not trigger_ids:
+            return
+
+        now = time.monotonic()
+        # Iterate over a copy — one-shot triggers mutate the set
+        for tid in list(trigger_ids):
+            trigger = self._triggers.get(tid)
+            if trigger is None:
+                continue
+
+            # Cooldown check for persistent triggers
+            if not trigger.once:
+                last_fire = self._last_fire_times.get(tid)
+                if last_fire is not None and (now - last_fire) < trigger.cooldown_seconds:
+                    continue
+
+            if not _matches(trigger.condition, value, previous_value):
+                continue
+
+            # Fire!
+            self._last_fire_times[tid] = now
+            notification = TriggerNotification(
+                trigger_id=tid,
+                field=field,
+                operator=trigger.condition.operator,
+                threshold=trigger.condition.value,
+                value=value,
+                previous_value=previous_value,
+                fired_at=timestamp,
+                vin=self._vin,
+            )
+
+            logger.info(
+                "Trigger %s fired: %s %s %s (value=%s prev=%s)",
+                tid,
+                field,
+                trigger.condition.operator.value,
+                trigger.condition.value,
+                value,
+                previous_value,
+            )
+
+            self._pending.append(notification)
+
+            for callback in self._on_fire_callbacks:
+                try:
+                    await callback(notification)
+                except Exception:
+                    logger.warning("Trigger fire callback failed for %s", tid, exc_info=True)
+
+            # Auto-delete one-shot triggers
+            if trigger.once:
+                self.delete(tid)
+
+
+def _matches(condition: TriggerCondition, value: Any, previous_value: Any) -> bool:
+    """Check whether a value satisfies a trigger condition."""
+    op = condition.operator
+
+    if op == TriggerOperator.CHANGED:
+        return bool(value != previous_value)
+
+    if op == TriggerOperator.EQ:
+        return bool(value == condition.value)
+
+    if op == TriggerOperator.NEQ:
+        return bool(value != condition.value)
+
+    if op in (TriggerOperator.ENTER, TriggerOperator.LEAVE):
+        return _matches_geofence(condition, value, previous_value)
+
+    # Numeric comparisons
+    try:
+        fval = float(value)
+        fthresh = float(condition.value)
+    except (TypeError, ValueError):
+        logger.debug(
+            "Numeric coercion failed for %s %s (value=%r, threshold=%r)",
+            condition.field,
+            op.value,
+            value,
+            condition.value,
+        )
+        return False
+
+    if op == TriggerOperator.LT:
+        return fval < fthresh
+    if op == TriggerOperator.GT:
+        return fval > fthresh
+    if op == TriggerOperator.LTE:
+        return fval <= fthresh
+    if op == TriggerOperator.GTE:
+        return fval >= fthresh
+
+    return False
+
+
+def _matches_geofence(condition: TriggerCondition, value: Any, previous_value: Any) -> bool:
+    """Evaluate geofence enter/leave conditions.
+
+    Requires a boundary crossing — being "already inside" doesn't fire
+    an ``enter`` trigger.  ``previous_value`` of ``None`` never fires.
+    """
+    from tescmd.openclaw.filters import haversine
+
+    if previous_value is None:
+        return False
+
+    geo = condition.value
+    if not isinstance(geo, dict):
+        logger.warning("Geofence trigger on %s has non-dict value: %r", condition.field, geo)
+        return False
+
+    try:
+        center_lat = float(geo["latitude"])
+        center_lon = float(geo["longitude"])
+        radius = float(geo["radius_m"])
+    except (KeyError, TypeError, ValueError):
+        logger.warning(
+            "Geofence trigger on %s has invalid config (need latitude, longitude, radius_m): %r",
+            condition.field,
+            geo,
+        )
+        return False
+
+    try:
+        cur_lat = float(value["latitude"])
+        cur_lon = float(value["longitude"])
+        prev_lat = float(previous_value["latitude"])
+        prev_lon = float(previous_value["longitude"])
+    except (KeyError, TypeError, ValueError):
+        logger.debug(
+            "Geofence data missing coordinates for %s (value=%r, prev=%r)",
+            condition.field,
+            value,
+            previous_value,
+        )
+        return False
+
+    cur_dist = haversine(cur_lat, cur_lon, center_lat, center_lon)
+    prev_dist = haversine(prev_lat, prev_lon, center_lat, center_lon)
+
+    if condition.operator == TriggerOperator.ENTER:
+        return cur_dist <= radius and prev_dist > radius
+    if condition.operator == TriggerOperator.LEAVE:
+        return cur_dist > radius and prev_dist <= radius
+
+    return False

tescmd/triggers/models.py

@@ -0,0 +1,93 @@
+"""Pydantic v2 models for the trigger/subscription system.
+
+Triggers let OpenClaw bots and MCP clients register conditions on
+telemetry fields and receive notifications when they fire.
+"""
+
+from __future__ import annotations
+
+import uuid
+from datetime import UTC, datetime
+from enum import Enum
+from typing import Any
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class TriggerOperator(str, Enum):
+    """Supported comparison operators for trigger conditions."""
+
+    LT = "lt"
+    GT = "gt"
+    LTE = "lte"
+    GTE = "gte"
+    EQ = "eq"
+    NEQ = "neq"
+    CHANGED = "changed"
+    ENTER = "enter"
+    LEAVE = "leave"
+
+
+# Operators that require no threshold value
+_NO_VALUE_OPS = frozenset({TriggerOperator.CHANGED})
+
+# Geofence operators require a dict with lat/lon/radius
+_GEOFENCE_OPS = frozenset({TriggerOperator.ENTER, TriggerOperator.LEAVE})
+
+
+class TriggerCondition(BaseModel):
+    """A single condition that a trigger evaluates.
+
+    For most operators, ``value`` is a numeric or string threshold.
+    For ``changed``, ``value`` is not required.
+    For ``enter``/``leave``, ``value`` is a dict with
+    ``latitude``, ``longitude``, and ``radius_m``.
+    """
+
+    field: str
+    operator: TriggerOperator
+    value: Any = None
+
+    @model_validator(mode="after")
+    def _validate_value_for_operator(self) -> TriggerCondition:
+        op = self.operator
+        if op in _GEOFENCE_OPS:
+            if not isinstance(self.value, dict):
+                raise ValueError(
+                    f"Operator '{op.value}' requires a dict value "
+                    "with latitude, longitude, radius_m"
+                )
+            missing = {"latitude", "longitude", "radius_m"} - set(self.value.keys())
+            if missing:
+                raise ValueError(f"Geofence value missing keys: {', '.join(sorted(missing))}")
+        elif op not in _NO_VALUE_OPS and self.value is None:
+            raise ValueError(f"Operator '{op.value}' requires a 'value' parameter")
+        return self
+
+
+def _make_trigger_id() -> str:
+    """Generate a short hex ID (12 chars from a UUID4)."""
+    return uuid.uuid4().hex[:12]
+
+
+class TriggerDefinition(BaseModel):
+    """A registered trigger with its condition and firing configuration."""
+
+    id: str = Field(default_factory=_make_trigger_id)
+    condition: TriggerCondition
+    once: bool = False
+    cooldown_seconds: float = Field(default=60.0, ge=0)
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+
+
+class TriggerNotification(BaseModel):
+    """Notification emitted when a trigger fires."""
+
+    trigger_id: str
+    field: str
+    operator: TriggerOperator
+    threshold: Any = None
+    value: Any = None
+    previous_value: Any = None
+    fired_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    vin: str = ""

tescmd-0.4.0.dist-info/METADATA

@@ -0,0 +1,300 @@
+Metadata-Version: 2.4
+Name: tescmd
+Version: 0.4.0
+Summary: A Python CLI for querying and controlling Tesla vehicles via the Fleet API
+Project-URL: Homepage, https://github.com/oceanswave/tescmd
+Project-URL: Repository, https://github.com/oceanswave/tescmd
+Project-URL: Issues, https://github.com/oceanswave/tescmd/issues
+Project-URL: Documentation, https://github.com/oceanswave/tescmd#readme
+Author: oceanswave
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cli,ev,fleet-api,tesla,vehicle
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: click>=8.1
+Requires-Dist: cryptography>=42.0
+Requires-Dist: httpx>=0.27
+Requires-Dist: keyring>=25.0
+Requires-Dist: mcp>=1.0
+Requires-Dist: protobuf>=5.29
+Requires-Dist: pydantic-settings>=2.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: rich>=13.0
+Requires-Dist: starlette>=0.37
+Requires-Dist: textual>=1.0
+Requires-Dist: uvicorn>=0.30
+Requires-Dist: websockets>=14.0
+Provides-Extra: ble
+Requires-Dist: bleak>=0.22; extra == 'ble'
+Provides-Extra: dev
+Requires-Dist: build>=1.0; extra == 'dev'
+Requires-Dist: grpcio-tools>=1.68; extra == 'dev'
+Requires-Dist: mypy-protobuf>=3.6; extra == 'dev'
+Requires-Dist: mypy>=1.13; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest-httpx>=0.34; extra == 'dev'
+Requires-Dist: pytest-xdist>=3.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <img src="images/tescmd_header.jpeg" alt="tescmd — Python CLI for Tesla Fleet API" width="100%">
+</p>
+
+# tescmd
+
+<p align="center">
+  <a href="https://pypi.org/project/tescmd/"><img src="https://img.shields.io/pypi/v/tescmd" alt="PyPI"></a>
+  <a href="https://pypi.org/project/tescmd/"><img src="https://img.shields.io/pypi/pyversions/tescmd" alt="Python"></a>
+  <a href="https://github.com/oceanswave/tescmd/actions/workflows/test.yml"><img src="https://img.shields.io/github/actions/workflow/status/oceanswave/tescmd/test.yml?branch=main&label=build" alt="Build"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/github/license/oceanswave/tescmd" alt="License"></a>
+  <a href="https://github.com/oceanswave/tescmd/releases"><img src="https://img.shields.io/github/v/release/oceanswave/tescmd" alt="GitHub Release"></a>
+</p>
+
+<p align="center">
+  <strong>The complete Python CLI for Tesla's Fleet API — built for humans and AI agents alike.</strong>
+</p>
+
+<p align="center">
+  Check your battery. Lock your doors. Stream live telemetry. Let Claude control your car.<br>
+  Two commands to install. One wizard to set up. Every API endpoint at your fingertips.
+</p>
+
+---
+
+## Quick Start
+
+```bash
+pip install tescmd
+tescmd setup
+```
+
+The setup wizard handles everything — Tesla Developer app creation, key generation, public key hosting, Fleet API registration, OAuth2 authentication, and vehicle key enrollment. Then you're ready:
+
+```bash
+tescmd charge status               # Battery and charging state
+tescmd climate on --wake            # Turn on climate (wakes if asleep)
+tescmd security lock --wake         # Lock the car
+tescmd nav waypoints "Home" "Work"  # Multi-stop navigation
+tescmd serve 5YJ3...               # Launch the live dashboard
+```
+
+---
+
+## See It in Action
+
+### Live TUI Dashboard
+
+`tescmd serve` launches a full-screen terminal dashboard with real-time telemetry, MCP server status, tunnel info, and connection metrics — powered by Textual.
+
+<p align="center">
+  <img src="images/tescmd_serve.png" alt="tescmd serve — live TUI dashboard" width="700">
+</p>
+
+### AI Agent Integration
+
+Every command doubles as an MCP tool. Claude Desktop, Claude Code, and other agent frameworks can query your vehicle, send commands, and react to telemetry — all through structured JSON with built-in cost protection.
+
+<p align="center">
+  <img src="images/tescmd_mcp.png" alt="tescmd MCP server — Claude Desktop integration" width="700">
+</p>
+
+### Rich Terminal Output
+
+Formatted tables in your terminal, structured JSON when piped — tescmd auto-detects the right output for the context.
+
+<p align="center">
+  <img src="images/tescmd_waypoints.png" alt="tescmd nav waypoints" width="500">
+</p>
+
+---
+
+## What You Get
+
+### Query & Control
+
+Full read/write access to Tesla's Fleet API: battery, charge, climate, locks, trunks, windows, sentry, navigation, media, speed limits, PINs, Powerwalls, and more. Every read command is cached with smart TTLs — bots can call tescmd as often as they want and only pay for the first request.
+
+### Fleet Telemetry Streaming
+
+Your vehicle pushes data directly to your machine via Tailscale Funnel — no polling, no per-request charges. Choose from field presets (`driving`, `charging`, `all`) or subscribe to 120+ individual fields. Sessions produce a wide-format CSV log by default.
+
+```bash
+tescmd serve 5YJ3... --fields driving     # Speed, location, power
+tescmd serve 5YJ3... --fields all         # Everything
+```
+
+### MCP Server for AI Agents
+
+`tescmd serve` exposes every command as an MCP tool with OAuth 2.1 authentication. Agents get deterministic JSON output, meaningful exit codes, and a `--wake` opt-in flag so they never trigger billable wake calls by accident.
+
+### OpenClaw Bridge
+
+Stream filtered telemetry to an [OpenClaw](https://openclaw.ai/) Gateway with per-field delta and throttle filtering. Bots on the gateway can send commands back — lock doors, start charging, set climate — through bidirectional dispatch.
+
+### Trigger Subscriptions
+
+Register conditions on any telemetry field — battery below 20%, speed above 80, location enters a geofence — and get notified via OpenClaw push events or MCP polling. Supports one-shot and persistent modes with cooldown.
+
+### Signed Vehicle Commands
+
+tescmd implements the [Vehicle Command Protocol](https://github.com/teslamotors/vehicle-command) with ECDH session management and HMAC-SHA256 signing. Once your key is enrolled, commands are signed transparently — no agent-side crypto needed.
+
+---
+
+## Cost Protection Built In
+
+Tesla's Fleet API is pay-per-use. A naive polling script can generate hundreds of dollars in monthly charges from a single vehicle. tescmd implements four layers of defense:
+
+| Layer | What it does |
+|---|---|
+| **Tiered caching** | Specs cached 1h, fleet lists 5m, standard queries 1m, location 30s |
+| **Wake confirmation** | Prompts before billable wake calls; `--wake` flag for scripts |
+| **Smart wake state** | Tracks recent wake confirmations, skips redundant attempts |
+| **Write invalidation** | Write commands auto-invalidate the relevant cache scope |
+
+Streaming telemetry via `tescmd serve` replaces polling entirely — flat cost regardless of data volume. See [API Costs](docs/api-costs.md) for the full breakdown.
+
+---
+
+## Commands
+
+| Group | Description |
+|---|---|
+| `setup` | Interactive first-run wizard |
+| `auth` | OAuth2 login, logout, token management, export/import |
+| `vehicle` | State queries, wake, rename, telemetry streaming, fleet status |
+| `charge` | Charge control, scheduling, departure, fleet management |
+| `climate` | HVAC, seats, steering wheel, bioweapon defense, overheat protection |
+| `security` | Lock/unlock, sentry, valet, PINs, speed limits, remote start |
+| `trunk` | Trunk, frunk, windows, sunroof, tonneau |
+| `media` | Playback control, volume, favorites |
+| `nav` | Send destinations, GPS coordinates, multi-stop waypoints, HomeLink |
+| `software` | Update status, scheduling, cancellation |
+| `energy` | Powerwall status, backup reserve, storm mode, grid config, history |
+| `billing` | Supercharger billing history and invoices |
+| `user` | Account info, region, orders, feature flags |
+| `sharing` | Driver management, vehicle sharing invites |
+| `key` | Key generation, deployment, enrollment, validation |
+| `serve` | Combined MCP + telemetry + OpenClaw TUI dashboard |
+| `mcp` | Standalone MCP server |
+| `openclaw` | Standalone OpenClaw bridge |
+| `cache` | Cache status and management |
+| `raw` | Direct Fleet API endpoint access |
+
+Every command supports `--format json` for scripting and `--help` for detailed usage. See the [Command Reference](docs/commands.md) for the full list.
+
+---
+
+## Installation
+
+```bash
+pip install tescmd
+```
+
+**Requirements:** Python 3.11+ and a [Tesla account](https://www.tesla.com) with a linked vehicle or energy product.
+
+**Recommended:** [GitHub CLI](https://cli.github.com) (`gh`) for automated key hosting via GitHub Pages, or [Tailscale](https://tailscale.com) for zero-config key hosting and telemetry streaming via Funnel.
+
+<details>
+<summary>Install from source</summary>
+
+```bash
+git clone https://github.com/oceanswave/tescmd.git
+cd tescmd
+pip install -e ".[dev]"
+```
+
+</details>
+
+---
+
+## Configuration
+
+tescmd resolves settings from CLI flags, environment variables (`.env` files loaded automatically), and defaults — in that order.
+
+<details>
+<summary>Environment variables</summary>
+
+```dotenv
+TESLA_CLIENT_ID=your-client-id
+TESLA_CLIENT_SECRET=your-client-secret
+TESLA_VIN=5YJ3E1EA1NF000000
+TESLA_REGION=na                    # na, eu, cn
+
+# Display units (optional — defaults to US)
+TESLA_TEMP_UNIT=F                  # F or C
+TESLA_DISTANCE_UNIT=mi             # mi or km
+TESLA_PRESSURE_UNIT=psi            # psi or bar
+
+# Or switch everything at once:
+#   tescmd --units metric charge status
+```
+
+See [docs/commands.md](docs/commands.md) for the full environment variable reference.
+
+</details>
+
+<details>
+<summary>Token storage</summary>
+
+Tokens are stored in the OS keyring by default (macOS Keychain, GNOME Keyring, Windows Credential Manager). On headless systems, tescmd falls back to a file-based store with restricted permissions. Transfer tokens between machines with `tescmd auth export` and `tescmd auth import`.
+
+</details>
+
+---
+
+## Documentation
+
+| | |
+|---|---|
+| [Setup Guide](docs/setup.md) | Step-by-step walkthrough of `tescmd setup` |
+| [Command Reference](docs/commands.md) | Detailed usage for every command |
+| [API Costs](docs/api-costs.md) | Cost breakdown, savings calculations, streaming comparison |
+| [Bot Integration](docs/bot-integration.md) | JSON schema, exit codes, headless auth |
+| [OpenClaw Bridge](docs/openclaw.md) | Gateway protocol, bidirectional commands, triggers, geofencing |
+| [MCP Server](docs/mcp.md) | Tool reference, OAuth 2.1, custom tools, trigger polling |
+| [Vehicle Command Protocol](docs/vehicle-command-protocol.md) | ECDH sessions and signed commands |
+| [Authentication](docs/authentication.md) | OAuth2 PKCE flow, token storage, scopes |
+| [Architecture](docs/architecture.md) | Layered design, module responsibilities |
+| [FAQ](docs/faq.md) | Common questions about costs, hosting, and configuration |
+| [Development](docs/development.md) | Contributing, testing, linting |
+
+---
+
+## Development
+
+```bash
+git clone https://github.com/oceanswave/tescmd.git && cd tescmd
+pip install -e ".[dev]"
+pytest                             # 1600+ tests
+ruff check src/ tests/ && mypy src/
+```
+
+---
+
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for release history.
+
+## License
+
+MIT
+
+<p align="center">
+  <img src="images/tescmd_logo.jpeg" alt="tescmd logo" width="300">
+</p>