location-tracker 1.0.0__py3-none-any.whl

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 David Condrey
+
+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.

PKG-INFO

@@ -0,0 +1,182 @@
+Metadata-Version: 2.4
+Name: location-tracker
+Version: 1.0.0
+Summary: Self-hosted location tracking dashboard with encrypted cookies, SQLite storage, and adaptive polling
+Project-URL: Homepage, https://github.com/dcondrey/location-tracker
+Project-URL: Repository, https://github.com/dcondrey/location-tracker
+Project-URL: Issues, https://github.com/dcondrey/location-tracker/issues
+Author-email: David Condrey <davidcondrey@me.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: dashboard,geolocation,google-maps,location,self-hosted,tracking
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.11
+Requires-Dist: cryptography>=44.0
+Requires-Dist: flask>=3.1.0
+Requires-Dist: folium>=0.20.0
+Requires-Dist: locationsharinglib>=5.0.3
+Requires-Dist: pandas>=3.0.3
+Requires-Dist: playwright-stealth>=2.0.3
+Requires-Dist: playwright>=1.60.0
+Requires-Dist: schedule>=1.2.2
+Provides-Extra: build
+Requires-Dist: pyinstaller>=6.0; extra == 'build'
+Provides-Extra: dev
+Requires-Dist: pip-audit>=2.7; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.11; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Location Tracker
+
+A self-hosted location tracking dashboard that polls Google Maps location sharing and visualizes movement history on an interactive map. Runs as a background daemon with a real-time web interface.
+
+## Features
+
+- **Real-time tracking** -- Polls Google Maps shared locations with adaptive intervals (15s when driving, 10min when stationary)
+- **Interactive dashboard** -- Dark-themed Leaflet map with path visualization, heatmaps, stop detection, and timeline scrubbing
+- **Self-tracking** -- Track your own position via browser geolocation
+- **Encrypted cookie storage** -- Google auth tokens encrypted at rest with Fernet; key stored in macOS Keychain
+- **Auto cookie refresh** -- Headless browser automatically re-authenticates when cookies expire
+- **SQLite storage** -- Location history stored in an indexed SQLite database with WAL mode
+- **Mobile responsive** -- Bottom-sheet sidebar on phones, touch-friendly controls
+- **Multiple export formats** -- JSON, CSV, and GeoJSON
+- **Persistent daemon** -- Optional launchd integration to survive reboots
+- **CLI query tools** -- Look up anyone's latest location or history from the terminal
+
+## Quick Start
+
+```bash
+# Clone and set up
+git clone https://github.com/dcondrey/location-tracker.git
+cd location-tracker
+./setup.sh
+
+# Or manually:
+uv sync
+uv run location-tracker setup
+
+# Configure your Google account
+uv run location-tracker config --email you@gmail.com
+
+# Authenticate with Google (opens browser)
+uv run location-tracker cookies
+
+# Start tracking
+uv run location-tracker on
+```
+
+The dashboard will be available at **http://tracker** (or `http://localhost:7070` if DNS isn't configured).
+
+## Prerequisites
+
+- **Python 3.11+**
+- **macOS** (uses Keychain for cookie encryption, launchd for persistence)
+- **uv** package manager ([install](https://docs.astral.sh/uv/getting-started/installation/))
+- A Google account with [location sharing](https://support.google.com/maps/answer/7326816) enabled
+
+## Commands
+
+### Core
+
+| Command | Description |
+|---------|-------------|
+| `on` | Start the tracker daemon and web dashboard |
+| `off` | Stop the tracker |
+| `status` | Check if the tracker is running |
+| `cookies` | Open browser to authenticate with Google |
+| `test` | Verify cookies are valid and list shared contacts |
+
+### Configuration
+
+| Command | Description |
+|---------|-------------|
+| `config --email you@gmail.com` | Set the Google account email |
+| `config` | Show current configuration |
+| `setup` | First-time setup: install Chromium, configure DNS and port forwarding |
+| `dns` | Set up `http://tracker` hostname |
+| `dns --remove` | Remove hostname and port forwarding |
+| `install` | Install as a launchd service (auto-start on login) |
+| `install --remove` | Remove the launchd service |
+
+### Data
+
+| Command | Description |
+|---------|-------------|
+| `where <person>` | Show someone's latest known location |
+| `history <person> --days 7` | Show recent location history |
+| `stats` | Print tracking statistics (distance, stops, dwell time) |
+| `map --days 7 --output map.html` | Generate a static HTML map |
+| `purge <days>` | Delete location records older than N days |
+
+## Dashboard
+
+The web dashboard provides:
+
+- **Map views** -- Road, Satellite, Hybrid, Terrain, and Dark map layers via Google/CARTO tiles
+- **Visualization modes** -- Path view (color-coded routes with stop nodes), Heatmap, and Points
+- **Time filtering** -- 24h, 3 days, 7 days, 30 days, 90 days, or all time
+- **Timeline scrubber** -- Drag to view historical positions with date/time labels
+- **Person cards** -- Click to focus; shows speed badge (Stationary/Walking/Driving/Highway)
+- **Self-tracking** -- Enable browser geolocation to appear on the map yourself
+- **Export** -- Download data as JSON, CSV, or GeoJSON
+- **Toast notifications** -- Visual feedback for all actions
+
+## How It Works
+
+### Polling
+
+The tracker polls Google Maps location sharing via [`locationsharinglib`](https://github.com/costastf/locationsharinglib). Polling frequency adapts to detected movement speed:
+
+| Speed | Category | Poll Interval |
+|-------|----------|--------------|
+| > 60 km/h | Highway | 15 seconds |
+| 10-60 km/h | Driving | 30 seconds |
+| 1-10 km/h | Walking | 60 seconds |
+| < 1 km/h | Stationary | 10 minutes |
+
+The person being tracked receives no notification. This is a passive read of data they have already chosen to share.
+
+### Security
+
+- **Cookie encryption** -- Google auth cookies are encrypted with `cryptography.Fernet` before writing to disk. The encryption key is stored in macOS Keychain, never on the filesystem.
+- **Localhost only** -- The Flask server binds to `127.0.0.1`; not accessible from the network.
+- **XSS protection** -- All user-controlled data is HTML-escaped before rendering.
+- **Input validation** -- Lat/lon bounds checking, type coercion, and error handling on all API endpoints.
+- **Atomic writes** -- SQLite with WAL mode for concurrent safety.
+
+### Data Storage
+
+Location history is stored in a local SQLite database (`location_history.db`) with indexed columns for fast queries. Existing `location_history.json` files are automatically migrated on first run.
+
+## Project Structure
+
+```
+location-tracker/
+  main.py            # CLI entry point and daemon management
+  tracker.py         # Location polling, stats, and map generation
+  dashboard.py       # Flask web server and API endpoints
+  db.py              # SQLite database layer
+  cookie_store.py    # Encrypted cookie storage (Fernet + Keychain)
+  get_cookies.py     # Browser-based Google authentication
+  templates/
+    index.html       # Dashboard HTML
+  static/
+    style.css        # Dashboard styles
+    app.js           # Dashboard JavaScript
+  setup.sh           # One-command install script
+  build.sh           # PyInstaller standalone build
+```
+
+## License
+
+MIT

README.md

@@ -0,0 +1,144 @@
+# Location Tracker
+
+A self-hosted location tracking dashboard that polls Google Maps location sharing and visualizes movement history on an interactive map. Runs as a background daemon with a real-time web interface.
+
+## Features
+
+- **Real-time tracking** -- Polls Google Maps shared locations with adaptive intervals (15s when driving, 10min when stationary)
+- **Interactive dashboard** -- Dark-themed Leaflet map with path visualization, heatmaps, stop detection, and timeline scrubbing
+- **Self-tracking** -- Track your own position via browser geolocation
+- **Encrypted cookie storage** -- Google auth tokens encrypted at rest with Fernet; key stored in macOS Keychain
+- **Auto cookie refresh** -- Headless browser automatically re-authenticates when cookies expire
+- **SQLite storage** -- Location history stored in an indexed SQLite database with WAL mode
+- **Mobile responsive** -- Bottom-sheet sidebar on phones, touch-friendly controls
+- **Multiple export formats** -- JSON, CSV, and GeoJSON
+- **Persistent daemon** -- Optional launchd integration to survive reboots
+- **CLI query tools** -- Look up anyone's latest location or history from the terminal
+
+## Quick Start
+
+```bash
+# Clone and set up
+git clone https://github.com/dcondrey/location-tracker.git
+cd location-tracker
+./setup.sh
+
+# Or manually:
+uv sync
+uv run location-tracker setup
+
+# Configure your Google account
+uv run location-tracker config --email you@gmail.com
+
+# Authenticate with Google (opens browser)
+uv run location-tracker cookies
+
+# Start tracking
+uv run location-tracker on
+```
+
+The dashboard will be available at **http://tracker** (or `http://localhost:7070` if DNS isn't configured).
+
+## Prerequisites
+
+- **Python 3.11+**
+- **macOS** (uses Keychain for cookie encryption, launchd for persistence)
+- **uv** package manager ([install](https://docs.astral.sh/uv/getting-started/installation/))
+- A Google account with [location sharing](https://support.google.com/maps/answer/7326816) enabled
+
+## Commands
+
+### Core
+
+| Command | Description |
+|---------|-------------|
+| `on` | Start the tracker daemon and web dashboard |
+| `off` | Stop the tracker |
+| `status` | Check if the tracker is running |
+| `cookies` | Open browser to authenticate with Google |
+| `test` | Verify cookies are valid and list shared contacts |
+
+### Configuration
+
+| Command | Description |
+|---------|-------------|
+| `config --email you@gmail.com` | Set the Google account email |
+| `config` | Show current configuration |
+| `setup` | First-time setup: install Chromium, configure DNS and port forwarding |
+| `dns` | Set up `http://tracker` hostname |
+| `dns --remove` | Remove hostname and port forwarding |
+| `install` | Install as a launchd service (auto-start on login) |
+| `install --remove` | Remove the launchd service |
+
+### Data
+
+| Command | Description |
+|---------|-------------|
+| `where <person>` | Show someone's latest known location |
+| `history <person> --days 7` | Show recent location history |
+| `stats` | Print tracking statistics (distance, stops, dwell time) |
+| `map --days 7 --output map.html` | Generate a static HTML map |
+| `purge <days>` | Delete location records older than N days |
+
+## Dashboard
+
+The web dashboard provides:
+
+- **Map views** -- Road, Satellite, Hybrid, Terrain, and Dark map layers via Google/CARTO tiles
+- **Visualization modes** -- Path view (color-coded routes with stop nodes), Heatmap, and Points
+- **Time filtering** -- 24h, 3 days, 7 days, 30 days, 90 days, or all time
+- **Timeline scrubber** -- Drag to view historical positions with date/time labels
+- **Person cards** -- Click to focus; shows speed badge (Stationary/Walking/Driving/Highway)
+- **Self-tracking** -- Enable browser geolocation to appear on the map yourself
+- **Export** -- Download data as JSON, CSV, or GeoJSON
+- **Toast notifications** -- Visual feedback for all actions
+
+## How It Works
+
+### Polling
+
+The tracker polls Google Maps location sharing via [`locationsharinglib`](https://github.com/costastf/locationsharinglib). Polling frequency adapts to detected movement speed:
+
+| Speed | Category | Poll Interval |
+|-------|----------|--------------|
+| > 60 km/h | Highway | 15 seconds |
+| 10-60 km/h | Driving | 30 seconds |
+| 1-10 km/h | Walking | 60 seconds |
+| < 1 km/h | Stationary | 10 minutes |
+
+The person being tracked receives no notification. This is a passive read of data they have already chosen to share.
+
+### Security
+
+- **Cookie encryption** -- Google auth cookies are encrypted with `cryptography.Fernet` before writing to disk. The encryption key is stored in macOS Keychain, never on the filesystem.
+- **Localhost only** -- The Flask server binds to `127.0.0.1`; not accessible from the network.
+- **XSS protection** -- All user-controlled data is HTML-escaped before rendering.
+- **Input validation** -- Lat/lon bounds checking, type coercion, and error handling on all API endpoints.
+- **Atomic writes** -- SQLite with WAL mode for concurrent safety.
+
+### Data Storage
+
+Location history is stored in a local SQLite database (`location_history.db`) with indexed columns for fast queries. Existing `location_history.json` files are automatically migrated on first run.
+
+## Project Structure
+
+```
+location-tracker/
+  main.py            # CLI entry point and daemon management
+  tracker.py         # Location polling, stats, and map generation
+  dashboard.py       # Flask web server and API endpoints
+  db.py              # SQLite database layer
+  cookie_store.py    # Encrypted cookie storage (Fernet + Keychain)
+  get_cookies.py     # Browser-based Google authentication
+  templates/
+    index.html       # Dashboard HTML
+  static/
+    style.css        # Dashboard styles
+    app.js           # Dashboard JavaScript
+  setup.sh           # One-command install script
+  build.sh           # PyInstaller standalone build
+```
+
+## License
+
+MIT

cookie_store.py

@@ -0,0 +1,100 @@
+import logging
+import os
+import subprocess
+import tempfile
+from pathlib import Path
+
+from cryptography.fernet import Fernet, InvalidToken
+
+log = logging.getLogger(__name__)
+
+KEYCHAIN_ACCOUNT = "location-tracker"
+KEYCHAIN_SERVICE = "cookie-encryption-key"
+ENCRYPTED_FILE = "cookies.enc"
+
+
+def _keychain_get():
+    """Retrieve the encryption key from macOS Keychain."""
+    result = subprocess.run(
+        ["security", "find-generic-password",
+         "-a", KEYCHAIN_ACCOUNT, "-s", KEYCHAIN_SERVICE, "-w"],
+        capture_output=True, text=True,
+    )
+    if result.returncode == 0:
+        return result.stdout.strip().encode()
+    return None
+
+
+def _keychain_set(key):
+    """Store the encryption key in macOS Keychain."""
+    subprocess.run(
+        ["security", "add-generic-password",
+         "-a", KEYCHAIN_ACCOUNT, "-s", KEYCHAIN_SERVICE,
+         "-w", key.decode(), "-U"],
+        capture_output=True,
+    )
+
+
+def _get_or_create_key():
+    """Get existing key from Keychain or generate and store a new one."""
+    key = _keychain_get()
+    if key:
+        return key
+    key = Fernet.generate_key()
+    _keychain_set(key)
+    log.info("Generated new encryption key and stored in Keychain.")
+    return key
+
+
+def encrypt_cookies(plaintext_path, encrypted_path=ENCRYPTED_FILE):
+    """Encrypt a plaintext cookies file and save to encrypted_path."""
+    key = _get_or_create_key()
+    fernet = Fernet(key)
+    with open(plaintext_path, "rb") as f:
+        data = f.read()
+    encrypted = fernet.encrypt(data)
+    with open(encrypted_path, "wb") as f:
+        f.write(encrypted)
+    os.unlink(plaintext_path)
+    log.info("Cookies encrypted and stored in %s. Plaintext removed.", encrypted_path)
+
+
+def decrypt_to_tempfile(encrypted_path=ENCRYPTED_FILE):
+    """Decrypt cookies to a temporary file. Caller must delete when done."""
+    if not Path(encrypted_path).exists():
+        return None
+    key = _keychain_get()
+    if not key:
+        log.error("No encryption key found in Keychain. Re-run: location-tracker cookies")
+        return None
+    fernet = Fernet(key)
+    try:
+        with open(encrypted_path, "rb") as f:
+            encrypted = f.read()
+        plaintext = fernet.decrypt(encrypted)
+    except InvalidToken:
+        log.error("Failed to decrypt cookies (key mismatch). Re-run: location-tracker cookies")
+        return None
+    fd, tmp_path = tempfile.mkstemp(suffix=".txt", prefix="cookies_")
+    with os.fdopen(fd, "wb") as f:
+        f.write(plaintext)
+    return tmp_path
+
+
+def has_encrypted_cookies(encrypted_path=ENCRYPTED_FILE):
+    """Check if encrypted cookies file exists."""
+    return Path(encrypted_path).exists()
+
+
+def has_plaintext_cookies(plaintext_path="cookies.txt"):
+    """Check if legacy plaintext cookies exist (for migration)."""
+    return Path(plaintext_path).exists()
+
+
+def migrate_plaintext_to_encrypted(plaintext_path="cookies.txt", encrypted_path=ENCRYPTED_FILE):
+    """Migrate existing plaintext cookies.txt to encrypted format."""
+    if has_plaintext_cookies(plaintext_path) and not has_encrypted_cookies(encrypted_path):
+        log.info("Migrating plaintext cookies to encrypted storage...")
+        encrypt_cookies(plaintext_path, encrypted_path)
+        return True
+    return False

dashboard.py

@@ -0,0 +1,242 @@
+import csv
+import io
+import json
+import logging
+import threading
+import time
+from datetime import UTC, datetime
+from pathlib import Path
+
+from flask import Flask, Response, jsonify, render_template, request
+
+from tracker import LocationTracker
+
+log = logging.getLogger(__name__)
+
+_TEMPLATE_DIR = Path(__file__).parent / "templates"
+_STATIC_DIR = Path(__file__).parent / "static"
+
+
+
+def _compute_speed_kmh(history):
+    """Compute recent speed in km/h from the last few data points across all people."""
+    import math
+    best_speed = 0.0
+    for person, locations in history.items():
+        if person == "Me" or len(locations) < 2:
+            continue
+        recent = locations[-5:]
+        for i in range(1, len(recent)):
+            prev, curr = recent[i - 1], recent[i]
+            lat1, lon1 = math.radians(prev['latitude']), math.radians(prev['longitude'])
+            lat2, lon2 = math.radians(curr['latitude']), math.radians(curr['longitude'])
+            dlat, dlon = lat2 - lat1, lon2 - lon1
+            a = math.sin(dlat / 2) ** 2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon / 2) ** 2
+            dist_m = 6371000 * 2 * math.asin(math.sqrt(a))
+            try:
+                t1 = datetime.fromisoformat(prev['timestamp'])
+                t2 = datetime.fromisoformat(curr['timestamp'])
+            except (ValueError, TypeError):
+                continue
+            dt = (t2 - t1).total_seconds()
+            if dt > 0:
+                speed = (dist_m / dt) * 3.6
+                best_speed = max(best_speed, speed)
+    return best_speed
+
+
+def _speed_info_for_points(points):
+    """Compute speed info for a person's location points."""
+    import math
+    if not points or len(points) < 2:
+        return {"speed_kmh": 0, "label": "Stationary", "cls": "badge-stationary"}
+    prev, last = points[-2], points[-1]
+    lat1, lon1 = math.radians(prev['latitude']), math.radians(prev['longitude'])
+    lat2, lon2 = math.radians(last['latitude']), math.radians(last['longitude'])
+    dlat, dlon = lat2 - lat1, lon2 - lon1
+    a = math.sin(dlat / 2) ** 2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon / 2) ** 2
+    dist_m = 6371000 * 2 * math.asin(math.sqrt(a))
+    try:
+        t1 = datetime.fromisoformat(prev['timestamp'])
+        t2 = datetime.fromisoformat(last['timestamp'])
+    except (ValueError, TypeError):
+        return {"speed_kmh": 0, "label": "Stationary", "cls": "badge-stationary"}
+    dt = (t2 - t1).total_seconds()
+    if dt <= 0:
+        return {"speed_kmh": 0, "label": "Stationary", "cls": "badge-stationary"}
+    kmh = (dist_m / dt) * 3.6
+    if kmh < 1:
+        return {"speed_kmh": round(kmh, 1), "label": "Stationary", "cls": "badge-stationary"}
+    if kmh < 10:
+        return {"speed_kmh": round(kmh, 1), "label": "Walking", "cls": "badge-slow"}
+    if kmh < 60:
+        return {"speed_kmh": round(kmh, 1), "label": "Driving", "cls": "badge-moving"}
+    return {"speed_kmh": round(kmh, 1), "label": "Highway", "cls": "badge-fast"}
+
+
+def _adaptive_interval(history, default_interval):
+    """Return (interval_seconds, speed_category) based on movement speed.
+
+    Polls aggressively during movement for accurate path tracking:
+    - Stationary (< 1 km/h for 5+ min): 600s (10 min)
+    - Slow (1-10 km/h, e.g. walking): 60s (1 min)
+    - Moderate (10-60 km/h, e.g. city driving): 30s
+    - Fast (> 60 km/h, e.g. highway): 15s
+    """
+    speed = _compute_speed_kmh(history)
+    if speed >= 60:
+        return 15, "fast"
+    elif speed >= 10:
+        return 30, "moderate"
+    elif speed >= 1:
+        return 60, "slow"
+    else:
+        # Check if stationary for 5+ minutes
+        for person, locations in history.items():
+            if person == "Me" or len(locations) < 2:
+                continue
+            last = locations[-1]
+            second_last = locations[-2]
+            try:
+                t1 = datetime.fromisoformat(second_last['timestamp'])
+                t2 = datetime.fromisoformat(last['timestamp'])
+            except (ValueError, TypeError):
+                continue
+            if (t2 - t1).total_seconds() >= 300:
+                return 600, "stationary"
+        return default_interval, "stationary"
+
+
+def run_dashboard(data_file, cookies_file, email, port, poll_interval):
+    app = Flask(__name__, template_folder=str(_TEMPLATE_DIR), static_folder=str(_STATIC_DIR))
+    app.logger.setLevel(logging.WARNING)
+    tracker = LocationTracker(cookies_file, email, data_file)
+
+    self_name = "Me"
+    poll_state = {"interval": poll_interval, "category": "moderate"}
+    poll_lock = threading.Lock()
+
+    def background_poll():
+        while True:
+            try:
+                tracker.poll_location()
+                interval, category = _adaptive_interval(tracker.history, poll_interval)
+                with poll_lock:
+                    poll_state["interval"] = interval
+                    poll_state["category"] = category
+                log.info("Next poll in %ds (speed: %s)", interval, category)
+                time.sleep(interval)
+            except Exception as e:
+                log.error("Poll thread error: %s: %s", type(e).__name__, e)
+                time.sleep(poll_interval)
+
+    poll_thread = threading.Thread(target=background_poll, daemon=True)
+    poll_thread.start()
+
+    @app.route('/')
+    def index():
+        return render_template('index.html')
+
+    @app.route('/api/locations')
+    def api_locations():
+        days = request.args.get('days', '0', type=str)
+        try:
+            days_int = int(days) if days != '0' else None
+        except ValueError:
+            days_int = None
+        from datetime import timedelta
+        since = None
+        if days_int:
+            since = (datetime.now(UTC) - timedelta(days=days_int)).isoformat()
+        data = tracker.db.get_history_dict(since=since)
+        # Attach speed_info per person so the frontend doesn't need to recompute
+        speed_info = {}
+        for person, pts in data.items():
+            speed_info[person] = _speed_info_for_points(pts)
+        return jsonify({"locations": data, "speed_info": speed_info})
+
+    @app.route('/api/stats')
+    def api_stats():
+        return jsonify(tracker.get_stats())
+
+    @app.route('/api/self-location', methods=['POST'])
+    def api_self_location():
+        data = request.get_json()
+        if not data or 'latitude' not in data or 'longitude' not in data:
+            return jsonify({'error': 'missing fields'}), 400
+
+        try:
+            lat = float(data['latitude'])
+            lon = float(data['longitude'])
+        except (TypeError, ValueError):
+            return jsonify({'error': 'invalid coordinates'}), 400
+
+        if not (-90 <= lat <= 90) or not (-180 <= lon <= 180):
+            return jsonify({'error': 'coordinates out of range'}), 400
+
+        tracker.db.add_location(
+            person=self_name,
+            timestamp=datetime.now(UTC).isoformat(),
+            latitude=lat,
+            longitude=lon,
+            accuracy=data.get('accuracy'),
+            address=f"({lat:.4f}, {lon:.4f})",
+        )
+        return jsonify({'ok': True})
+
+    @app.route('/api/poll-status')
+    def api_poll_status():
+        with poll_lock:
+            return jsonify({
+                'current_interval': poll_state['interval'],
+                'speed_category': poll_state['category'],
+            })
+
+    @app.route('/api/export')
+    def api_export():
+        fmt = request.args.get('format', 'json')
+        history = tracker.history
+
+        if fmt == 'csv':
+            buf = io.StringIO()
+            writer = csv.writer(buf)
+            writer.writerow(['person', 'timestamp', 'latitude', 'longitude',
+                             'accuracy', 'battery', 'charging', 'address'])
+            for person, locations in history.items():
+                for loc in locations:
+                    writer.writerow([
+                        person, loc.get('timestamp'), loc.get('latitude'),
+                        loc.get('longitude'), loc.get('accuracy'),
+                        loc.get('battery'), loc.get('charging'),
+                        loc.get('address'),
+                    ])
+            return Response(buf.getvalue(), mimetype='text/csv',
+                            headers={'Content-Disposition': 'attachment; filename=location-history.csv'})
+
+        if fmt == 'geojson':
+            features = []
+            for person, locations in history.items():
+                for loc in locations:
+                    features.append({
+                        "type": "Feature",
+                        "geometry": {
+                            "type": "Point",
+                            "coordinates": [loc.get('longitude'), loc.get('latitude')],
+                        },
+                        "properties": {
+                            "person": person,
+                            "timestamp": loc.get('timestamp'),
+                            "accuracy": loc.get('accuracy'),
+                            "battery": loc.get('battery'),
+                            "charging": loc.get('charging'),
+                            "address": loc.get('address'),
+                        },
+                    })
+            geojson = {"type": "FeatureCollection", "features": features}
+            return Response(json.dumps(geojson), mimetype='application/geo+json',
+                            headers={'Content-Disposition': 'attachment; filename=location-history.geojson'})
+
+        return jsonify(history)
+
+    log.info("Dashboard running at http://tracker (port %d)", port)
+    app.run(host='127.0.0.1', port=port, debug=False)