# Status

A self-hosted uptime monitor and status page. HTTP checks every 3 minutes,
daily Lighthouse audits, weekly in-process SEO crawls, and alerts via email
and Discord webhook on state transitions.

Single-binary axum service backed by SQLite. Originally a Django service;
that codebase has been retired and replaced with this rust port. The data
from the Django era can be migrated in via `./status migrate <django.sqlite3>`
(preserves Property UUIDs so existing public status URLs keep working).


## Features

- HTTP uptime checks with rolling uptime percentages and recent-uptime bars
- Lighthouse audits (performance, accessibility, best practices, SEO) with
  weighted breakdown and top savings opportunities
- In-process SEO crawler (reqwest + scraper) extracting title, description,
  canonical, OG tags, and H1 per page, plus 38 SEO/a11y/perf/security checks
- Security header analysis (HTTPS, HSTS, HSTS preload, X-Frame-Options, etc.)
- Alert state machine with debounce on flaps (two consecutive non-200s to
  go down, immediate 200 to come back up)
- Direct-to-MX email and Discord webhook alerts on state transitions only
- PDF + markdown report export per property (PDF rendered in-process via
  embedded Typst, no chromium subprocess; markdown rendered from a template)


## Stack

| Concern         | Crate / Tool                                          |
|-----------------|-------------------------------------------------------|
| Web framework   | axum + tokio                                          |
| Database        | sqlx + SQLite (WAL, `synchronous=NORMAL`)             |
| Auth            | tower-cookies signed sessions                         |
| Template engine | minijinja                                             |
| HTTP client     | reqwest (rustls)                                      |
| Crawler         | scraper + html5ever + robotstxt + hickory-resolver    |
| Lighthouse      | `bun run --bun node_modules/.bin/lighthouse`          |
| Email           | lettre (direct-to-MX, opportunistic STARTTLS)         |
| PDF             | embedded Typst (`typst` + `typst-pdf` + `typst-kit`)  |
| Static assets   | Vite + Bun, Bootstrap 5, Chart.js, monaspace font     |


## Requirements

You need docker installed for a quick production start, or you can read the
`Dockerfile` for the exact dependency list and adjust for your distro.

For local development:

- rust (cargo) for the backend
- bun for everything JS: the frontend bundler (Vite) AND the `lighthouse` CLI.
  The rust binary invokes lighthouse via `bun run --bun node_modules/.bin/lighthouse`,
  which symlinks `node` → `bun` so the shim's `#!/usr/bin/env node` shebang
  resolves to bun's runtime. No nodejs/npm required.
- chromium for Lighthouse's own audits (PDF reports do not need chromium;
  they go through embedded Typst)


## Running locally

    cp samplefiles/env.sample .env  # set STATUS_PASSWORD at minimum
    make run                         # vite watch + cargo run on port 8000

Server boots, applies migrations, and starts the scheduler in-process. Open
<http://localhost:8000>, log in with the password from `.env`, add a property
URL.


## Configuration

All config comes from `.env` (loaded via `dotenvy`):

| Variable | Required | Purpose |
|---|---|---|
| `STATUS_PASSWORD` | yes | Single operator password |
| `BASE_URL` | yes for prod | Used in absolute URLs (sitemap, og tags, alert email links). No trailing slash |
| `PORT` | no (default `8000`) | HTTP listen port |
| `STATUS_COOKIE_SECRET` | no | 32+ bytes for signing the session cookie. Falls back to a SHA-512 of the password, so rotating the password invalidates sessions |
| `ALERT_EMAIL` | no | Recipient for outage / recovery emails. Leave unset to disable email |
| `DISCORD_WEBHOOK_URL` | no | Discord webhook for outage / recovery embeds. Leave unset to disable |
| `STATUS_DATA_DIR` | no (default `./data`) | Where the SQLite db lives. Production sets this to `/data` |
| `STATUS_ROOT` | no | Override the project root (where `templates/`, `dist/`, `migrations/` are read from) |
| `CHROMIUM_BIN` | no | Path to chromium for Lighthouse. Falls back to `PATH` lookup, then a `/opt/playwright-browsers/` glob |


## Make targets

| Target | What it does |
|---|---|
| `make run` (default) | Vite watch + `cargo run` on port 8000, plus the in-process scheduler |
| `make build` | Vite assets + release binary (`target/release/status`) |
| `make start` | Run the release binary (after `make build`) |
| `make pull` | rsync the production sqlite db from `git remote server` into `data/` |
| `make migrate FROM=<path-to-django.sqlite3>` | One-shot import of an existing Django status database, preserving Property UUIDs so public status URLs keep working. Add `FORCE=1` to wipe first |
| `make push` | `git push` to every configured remote |
| `make clean` | Remove `target/`, `dist/`, `frontend/node_modules/`, root `node_modules/`, and `data/` |

There are no tests or linters configured.


## Importing an existing Django status DB

If you have a SQLite from the Django version of this project, you can keep
your existing properties + check history:

    make migrate FROM=/path/to/django/db.sqlite3

Add `FORCE=1` to wipe an existing local rust DB first. The migration preserves
Property UUIDs so any public status URLs you've shared keep working.


## Production deploy

The same `git push server master` post-receive hook flow used by the rest of
my projects:

Server:

    apk update && apk upgrade && apk add docker docker-compose caddy git iptables ip6tables ufw
    ufw allow 22/tcp && ufw allow 80/tcp && ufw allow 443/tcp && ufw --force enable
    rc-update add docker boot && service docker start
    mkdir -p /srv/git/status.git && cd /srv/git/status.git && git init --bare

Local:

    git remote add server root@status.example.com:/srv/git/status.git
    git push --set-upstream server master

Server:

    mkdir -p /srv/docker && cd /srv/docker && git clone /srv/git/status.git status && cd /srv/docker/status
    cp samplefiles/Caddyfile.sample /etc/caddy/Caddyfile
    cp samplefiles/env.sample .env  # edit STATUS_PASSWORD, BASE_URL, ALERT_EMAIL, DISCORD_WEBHOOK_URL
    cp samplefiles/post-receive.sample /srv/git/status.git/hooks/post-receive && chmod +x /srv/git/status.git/hooks/post-receive
    mkdir -p /srv/data/status && chown -R 1000:1000 /srv/data/status
    docker-compose up --build --detach
    rc-update add caddy boot && service caddy start


## Backups

All data is stored in `/srv/data/status/` and your repo is in
`/srv/git/status.git/`. Back up both of those folders and you have a complete
backup. The `Caddyfile` and `.env` are easy enough to recreate but back them
up too if you want to be thorough.


## Support

I won't be providing user support for this project. I'm happy to accept good
pull requests and fix bugs but I don't have time to help people run or use
this project.