feat: eigener Medien-Dienst statt Fivemanage Lite — Server-Grundgeruest

Ein Container statt vier: Hono, SQLite, Dateien auf einer Platte. Kein
PostgreSQL, kein MinIO, kein ClickHouse. Das ist nicht die kleine Loesung,
sondern die, die man nicht pflegt — eine Sicherung ist ein cp -a.

Der Ausloeser war nicht der Funktionsumfang von Lite, sondern dessen
Zustand. web/src/utils/http-util.ts wirft jeden Fehler als new Error(...),
die Hooks pruefen auf "instanceof ApiError" — damit wird jeder Fehlschlag
lautlos verschluckt. "Create organization" meldet weder Erfolg noch
Misserfolg; das Ergebnis waren 19 gleichnamige Organisationen, die sich auch
nicht loeschen lassen, weil die Route fehlt. Von allem, was Lite darueber
hinaus kann, haben wir nichts gebraucht.

Zwei Hostnamen, ein Prozess: unter FILES_HOST gibt es ausschliesslich
Dateien — kein Dashboard, keine API, nichts anzumelden. Das haelt die
oeffentliche Adresse frei von Angriffsflaeche und die URLs huebsch, ohne
/f/-Praefix. Die Vorlage im Handy bleibt {model}.webp.

Der Pfad ist der Schluessel: X-Path legt die Datei genau dort ab, wo der
Aufrufer sie erwartet. Bei Lite haetten wir die zurueckgegebenen Adressen in
einer urls.json mitschleppen muessen — vorhersagbare URLs sind fuer das
Fotostudio die ganze Voraussetzung.

storage.ts bereinigt Pfade NICHT, es lehnt sie ab. Ein zurechtgebogener Pfad
legt die Datei unter einem anderen Namen ab als dem erwarteten, und das faellt
erst auf, wenn das Bild fehlt.

Typprueft. Noch nicht gestartet, noch nicht getestet — das ist der naechste
Schritt und steht in ROADMAP.md.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

.gitignore

@@ -1,2 +1,9 @@
 # Die echten Geheimnisse. Nur .env.example gehoert ins Repo.
 .env
+
+# Node
+node_modules/
+dist/
+
+# Die Ablage des Dienstes: Bilder und SQLite. Gehoert ins Volume, nie ins Repo.
+data/

ROADMAP.md

@@ -0,0 +1,156 @@
+# d4rk_media — Roadmap
+
+Eigener Medien-Dienst für alle FiveM-Ressourcen: Dateien annehmen, ablegen,
+ausliefern, in einem Dashboard verwalten.
+
+**Warum nicht Fivemanage Lite.** Der Stack lief am Ende — PostgreSQL, MinIO,
+Dashboard, alles grün. Was an ihm nicht zu reparieren war, ist die Qualität
+der Oberfläche: `http-util.ts` wirft jeden Fehler als `new Error(…)`, die
+Hooks prüfen auf `instanceof ApiError`, und damit wird **jeder** Fehlschlag
+lautlos verschluckt. `Create organization` gibt weder Erfolg noch Misserfolg
+zurück — das Ergebnis waren 19 gleichnamige Organisationen, weil ein Knopf
+ohne Rückmeldung wie ein kaputter Knopf aussieht. Löschen geht nicht, die
+Route existiert nicht. Das ist kein Bedienfehler und keine fehlende Funktion,
+das ist 0.1.0-beta.
+
+Dazu kam: von dem, was Lite über eine Dateiablage hinaus kann — Mandanten,
+strukturiertes Logging, ClickHouse — haben wir nichts gebraucht und alles
+mitgeschleppt.
+
+---
+
+## Der Zuschnitt
+
+**Ein Container.** SQLite statt PostgreSQL, Dateien auf einer Platte statt
+MinIO. Das ist nicht die kleine Lösung, sondern die, die man nicht pflegt:
+kein zweiter Dienst, kein Passwort dazwischen, und eine Sicherung ist ein
+`cp -a` über ein Volume. Wenn daraus je Millionen Zeilen werden, wird
+`server/src/db.ts` ausgetauscht — die Aufrufer merken davon nichts.
+
+**Zwei Hostnamen, ein Prozess.**
+
+| | |
+|---|---|
+| `fivecdn.d4rkst3r.de` | nur Dateien. Kein Dashboard, keine API, nichts anzumelden |
+| `fivemanage.d4rkst3r.de` | Dashboard und API |
+
+Das hält die öffentliche Adresse frei von Angriffsfläche und die URLs hübsch:
+`https://fivecdn.d4rkst3r.de/vehicles/adder.webp`, ohne `/f/`-Präfix. Die
+Vorlage im Handy bleibt damit schlicht `{model}.webp`.
+
+**Der Pfad ist der Schlüssel.** `X-Path: vehicles/adder.webp` legt die Datei
+genau dort ab. Vorhersagbare URLs sind für das Fotostudio die ganze
+Voraussetzung — bei Lite hätten wir die zurückgegebenen Adressen in einer
+`urls.json` mitschleppen müssen.
+
+**Nicht nachgebaut wird das Logging.** Genau dafür schleppt Fivemanage
+ClickHouse mit, und genau da ist der Wartungsaufwand echt. Wenn Logs kommen
+sollen, ist das ein eigenes Projekt mit eigener Entscheidung.
+
+---
+
+## Stand
+
+### ✅ Fertig — Server-Grundgerüst
+
+```
+server/src/config.ts     Einstellungen, alle aus der Umgebung
+server/src/db.ts         SQLite: users, sessions, tokens, media
+server/src/auth.ts       scrypt, Sitzungen, Token-Hashes
+server/src/storage.ts    Pfadprüfung, atomares Schreiben, MIME
+server/src/routes/upload.ts   die API für Skripte
+server/src/routes/dash.ts     die API fürs Dashboard
+server/src/index.ts      Host-Weiche, Dateiauslieferung, Start
+```
+
+Typprüfung läuft durch. **Noch nicht gestartet und nicht getestet.**
+
+Die API für Skripte:
+
+```
+POST   /api/upload          Bearer-Token
+                            X-Path        vehicles/adder.webp   (optional)
+                            X-Encoding    base64                (für Lua)
+                            X-Overwrite   false                 (Standard: ja)
+                            → { url, path, size, sha256, mime, replaced }
+
+DELETE /api/media/<pfad>    Token braucht can_delete
+GET    /api/exists/<pfad>   für "nur fehlende" im Serienlauf
+```
+
+Drei Rumpfformen — `multipart/form-data`, Base64, rohe Bytes. Base64 ist für
+FiveM: `PerformHttpRequest` schickt einen Lua-String, und im Fotostudio kommt
+das Bild ohnehin als Data-URL aus dem NUI.
+
+Die API fürs Dashboard: Anmeldung, Passwortwechsel, Medienliste mit Suche und
+Paginierung, Einzel- und Sammellöschung, Statistik nach Ordnern,
+Token-Verwaltung.
+
+### ⬜ Als Nächstes
+
+**1 · Smoke-Test.** Server lokal starten, Token anlegen, ein Bild hoch- und
+wieder abrufen. Vor Docker, vor allem anderen.
+
+**2 · Dockerfile und Compose.** Ein Abbild, das Server und gebaute Oberfläche
+ausliefert; ein Volume für `data/`; ein Port für NPM. In Portainer aus diesem
+Repo deploybar — **`Compose path` nimmt EINE Datei**, Ergänzungen werden
+stillschweigend ignoriert. Das hat uns bei Lite einen Nachmittag gekostet.
+
+**3 · `server/upload.lua` im Fotostudio.** `Upload.put(pfad, bytes) → url`.
+Token in `config.upload.lua`, server-only, gitignored, mit committetem
+`.example` — nie im NUI, dort hat es jeder Spieler im Speicher. An den
+Serienlauf hängen, damit freigestellte Bilder nach der Freigabe sofort
+hochgehen.
+
+Nach diesem Schritt ist das erreicht, worum es ursprünglich ging.
+
+**4 · Dashboard.** React 18, TypeScript, Vite 5, Tailwind 4 (CSS-first),
+Lucide, Zustand. **Kein Konsta** — das ist für die Handy-Oberfläche richtig,
+für ein Dashboard am Monitor nicht.
+
+Anmeldung · Galerie mit Vorschau, Suche, Mehrfachauswahl · Löschen ·
+Speicherverbrauch nach Ordnern · Token-Verwaltung, Klartext genau einmal.
+
+> **Die eine Regel:** jeder Knopf gibt Rückmeldung, auch der erfolgreiche.
+> Das ist der Fehler, an dem wir bei Fivemanage einen Nachmittag verloren
+> haben, und er ist billig zu vermeiden.
+
+**5 · Umzug.** Root-`docker-compose.yml` wird unsere; die Fivemanage-Dateien
+wandern nach `legacy/`. Erst wenn unserer trägt — bis dahin bleibt der
+Lite-Stack als Vergleichsmaßstab laufen.
+
+### ⬜ Später, wenn es sich lohnt
+
+- Vorschaubilder serverseitig (spart dem Dashboard das Laden von 900 Vollbildern)
+- Namensräume je Ressource, mit eigenem Token und eigener Statistik
+- Spieler-Metadaten an einem Upload (wer, wann, welcher Server)
+- Aufräumregeln: was älter als X ist und zu keinem Datensatz gehört
+- Mehrere Benutzer statt nur `admin`
+
+---
+
+## Offene Entscheidungen
+
+- **Sicherung.** Ein Volume mit Bildern und `media.db`. Restic gegen die
+  Nextcloud? Oder reicht ein `docker cp` vor größeren Änderungen?
+- **Bilder aus dem Spiel** (Screenshots, Clips von Spielern) — dafür brauchte
+  es Größenbegrenzungen je Token und vermutlich eine Warteschlange. Erst
+  planen, wenn es ansteht.
+
+---
+
+## Was aus dem Fivemanage-Anlauf hängen bleibt
+
+Steht ausführlich im README, hier nur die Kurzfassung — es sind alles Dinge,
+die uns wieder begegnen:
+
+1. **Portainer nimmt unter `Compose path` eine Datei.** Ergänzungen werden
+   stillschweigend übergangen: alle Container gesund, alles 502.
+2. **Host-Ports an `0.0.0.0` binden, nicht an `127.0.0.1`.** NPM liegt im
+   Standard-Bridge-Netz und kommt über die Docker-Brücke, nicht über Loopback.
+   Zu macht der Port die Firewall.
+3. **Belegt auf diesem Server:** 80, 81, 443, 2224, 3000, 3080, 3478, 8000,
+   8080, 8090, 9000, 9443, 11000. Unsere: 9100 und 9101.
+4. **`9101:8080` ist keine Kollision.** Nur die linke Zahl muss einmalig sein.
+5. **Ein Dienst, der ohne Konfiguration hochfährt, kostet mehr Zeit als
+   einer, der sich weigert.** Deshalb bricht `config.ts` beim Start ab.

server/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "d4rk-media-server",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "@hono/node-server": "^1.13.7",
+    "better-sqlite3": "^11.7.0",
+    "hono": "^4.6.14"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.12",
+    "@types/node": "^22.10.2",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2"
+  }
+}

server/src/auth.ts

@@ -0,0 +1,123 @@
+// Anmeldung, Sitzungen und Tokens.
+//
+// Ohne Bibliothek, aber nicht selbstgestrickt: scrypt und timingSafeEqual
+// kommen aus node:crypto. Was hier selbst geschrieben ist, ist die Verdrahtung
+// — nicht die Kryptografie.
+
+import {
+    randomBytes,
+    scryptSync,
+    timingSafeEqual,
+    createHash,
+} from 'node:crypto'
+import { db, now, type Token, type User } from './db.js'
+import { config } from './config.js'
+
+const SCRYPT_N = 16384 // ~100 ms je Pruefung, spuerbar fuer einen Angreifer
+const KEY_LENGTH = 64
+
+/** Format: scrypt$<N>$<salt-hex>$<hash-hex>. Das Verfahren steht im String,
+ *  damit spaetere Parameter alte Passwoerter nicht ungueltig machen. */
+export function hashPassword(password: string): string {
+    const salt = randomBytes(16)
+    const key = scryptSync(password, salt, KEY_LENGTH, { N: SCRYPT_N })
+    return `scrypt$${SCRYPT_N}$${salt.toString('hex')}$${key.toString('hex')}`
+}
+
+export function verifyPassword(password: string, stored: string): boolean {
+    const [scheme, n, saltHex, keyHex] = stored.split('$')
+    if (scheme !== 'scrypt' || !n || !saltHex || !keyHex) return false
+
+    const key = scryptSync(password, Buffer.from(saltHex, 'hex'), KEY_LENGTH, {
+        N: Number(n),
+    })
+    const expected = Buffer.from(keyHex, 'hex')
+    // Laengen muessen vor timingSafeEqual stimmen, sonst wirft es.
+    if (key.length !== expected.length) return false
+    return timingSafeEqual(key, expected)
+}
+
+// ---------------------------------------------------------------- Sitzungen
+
+export const SESSION_COOKIE = 'sid'
+
+export function createSession(userId: number): { id: string; expiresAt: number } {
+    const id = randomBytes(32).toString('base64url')
+    const expiresAt = now() + config.sessionDays * 86_400_000
+    db.prepare(
+        'INSERT INTO sessions (id, user_id, created_at, expires_at) VALUES (?, ?, ?, ?)',
+    ).run(id, userId, now(), expiresAt)
+    return { id, expiresAt }
+}
+
+export function userForSession(sessionId: string | undefined): User | null {
+    if (!sessionId) return null
+    const row = db
+        .prepare(
+            `SELECT u.* FROM sessions s
+             JOIN users u ON u.id = s.user_id
+             WHERE s.id = ? AND s.expires_at > ?`,
+        )
+        .get(sessionId, now()) as User | undefined
+    return row ?? null
+}
+
+export function destroySession(sessionId: string) {
+    db.prepare('DELETE FROM sessions WHERE id = ?').run(sessionId)
+}
+
+// ------------------------------------------------------------------- Tokens
+
+/** Der Klartext-Token. Traegt ein Praefix, damit er in einem Log oder einer
+ *  Konfigurationsdatei sofort als solcher zu erkennen ist. */
+export function generateToken(): string {
+    return `d4rk_${randomBytes(24).toString('base64url')}`
+}
+
+export function tokenHash(token: string): string {
+    return createHash('sha256').update(token).digest('hex')
+}
+
+/** Den Token zu einem Authorization-Kopf finden.
+ *
+ *  Gesucht wird ueber den HASH, nicht ueber den Klartext — in der Datenbank
+ *  steht nichts, womit jemand hochladen koennte, der sie in die Haende
+ *  bekommt. */
+export function tokenFromHeader(header: string | undefined): Token | null {
+    if (!header) return null
+    const match = /^Bearer\s+(.+)$/i.exec(header.trim())
+    if (!match?.[1]) return null
+
+    const row = db
+        .prepare('SELECT * FROM tokens WHERE hash = ?')
+        .get(tokenHash(match[1])) as Token | undefined
+    if (!row) return null
+
+    db.prepare('UPDATE tokens SET last_used_at = ? WHERE id = ?').run(now(), row.id)
+    return row
+}
+
+/** Darf dieser Token auf diesen Pfad schreiben? */
+export function tokenAllows(token: Token, path: string): boolean {
+    if (!token.prefix) return true
+    const prefix = token.prefix.replace(/\/+$/, '') + '/'
+    return path.startsWith(prefix)
+}
+
+// -------------------------------------------------------------------- Start
+
+/** Den ersten Benutzer anlegen, falls noch keiner da ist.
+ *
+ *  Nur DANN — ein geaendertes ADMIN_PASSWORD setzt ein bestehendes Passwort
+ *  nicht zurueck. Wer sich ausgesperrt hat, loescht die Zeile in der Datenbank
+ *  und startet neu. */
+export function ensureAdmin() {
+    const count = db.prepare('SELECT COUNT(*) AS n FROM users').get() as { n: number }
+    if (count.n > 0) return
+
+    db.prepare(
+        'INSERT INTO users (username, password_hash, created_at) VALUES (?, ?, ?)',
+    ).run(config.adminUsername, hashPassword(config.adminPassword), now())
+
+    console.log(`[auth] Benutzer "${config.adminUsername}" angelegt.`)
+}

server/src/config.ts

@@ -0,0 +1,82 @@
+// Alle Einstellungen an einer Stelle, alle aus der Umgebung.
+//
+// Was fehlt, faellt beim START auf und nicht beim ersten Upload. Das ist
+// Absicht: ein Dienst, der bereitwillig hochfaehrt und erst Stunden spaeter
+// merkt, dass ihm die halbe Konfiguration fehlt, kostet mehr Zeit als einer,
+// der sich sofort weigert.
+
+import { existsSync, mkdirSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+function required(name: string): string {
+    const value = process.env[name]
+    if (!value) {
+        console.error(`[config] ${name} fehlt. Ohne die Variable startet der Dienst nicht.`)
+        process.exit(1)
+    }
+    return value
+}
+
+function optional(name: string, fallback: string): string {
+    return process.env[name] || fallback
+}
+
+function number(name: string, fallback: number): number {
+    const raw = process.env[name]
+    if (!raw) return fallback
+    const parsed = Number(raw)
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        console.error(`[config] ${name}="${raw}" ist keine sinnvolle Zahl.`)
+        process.exit(1)
+    }
+    return parsed
+}
+
+/** Wohin die Dateien und die Datenbank kommen. EIN Ordner, damit eine
+ *  Sicherung aus genau einem `cp -a` besteht. */
+const dataDir = resolve(optional('DATA_DIR', './data'))
+const filesDir = resolve(dataDir, 'files')
+for (const dir of [dataDir, filesDir]) {
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
+}
+
+/** Unter welcher Adresse die Dateien oeffentlich stehen. Daraus wird die URL
+ *  gebaut, die nach dem Upload zurueckkommt — und die im Handy in der Vorlage
+ *  steht. Ohne abschliessenden Schraegstrich. */
+const publicUrl = required('PUBLIC_URL').replace(/\/+$/, '')
+
+export const config = {
+    port: number('PORT', 8080),
+    dataDir,
+    filesDir,
+    dbPath: resolve(dataDir, 'media.db'),
+
+    publicUrl,
+
+    /** Der Hostname, unter dem NUR Dateien ausgeliefert werden.
+     *
+     *  Trifft eine Anfrage unter diesem Namen ein, gibt es weder Dashboard
+     *  noch API — nur GET auf Dateien. Das haelt die oeffentliche Adresse frei
+     *  von jeder Angriffsflaeche und macht die URLs zugleich huebsch:
+     *  https://fivecdn.d4rkst3r.de/vehicles/adder.webp statt eines /f/-Praefix.
+     *
+     *  Leer lassen, wenn alles unter einem Namen laufen soll — dann liegen die
+     *  Dateien unter /f/. */
+    filesHost: optional('FILES_HOST', new URL(publicUrl).host),
+
+    /** Wird beim Start angelegt, falls es noch keinen Benutzer gibt. */
+    adminPassword: required('ADMIN_PASSWORD'),
+    adminUsername: optional('ADMIN_USERNAME', 'admin'),
+
+    /** Groesste erlaubte Datei. Ein freigestelltes Fahrzeugbild wiegt rund
+     *  200 KB; 64 MB lassen Luft fuer Videos, ohne dass ein Fehlgriff die
+     *  Platte fuellt. */
+    maxUploadBytes: number('MAX_UPLOAD_MB', 64) * 1024 * 1024,
+
+    /** Wie lange eine Anmeldung im Dashboard haelt. */
+    sessionDays: number('SESSION_DAYS', 30),
+
+    dev: process.env.NODE_ENV !== 'production',
+} as const
+
+export type Config = typeof config

server/src/db.ts

@@ -0,0 +1,101 @@
+// Die Ablage: SQLite, eine Datei neben den Bildern.
+//
+// Warum nicht PostgreSQL: weil hier eine Handvoll Tabellen liegt, auf die ein
+// Server schreibt. SQLite ist dafuer nicht die kleine Loesung, sondern die
+// angemessene — sie kostet keinen Container, keine Verbindung, kein Passwort,
+// und eine Sicherung ist ein Dateikopie. Wenn daraus je Millionen Zeilen
+// werden, tauschen wir dieses Modul aus; die Aufrufer sehen davon nichts.
+
+import Database from 'better-sqlite3'
+import { config } from './config.js'
+
+export const db = new Database(config.dbPath)
+
+// WAL: Lesen blockiert Schreiben nicht. Bei einem Dashboard, das waehrend
+// eines laufenden Serienuploads die Galerie zeigt, ist genau das der Fall.
+db.pragma('journal_mode = WAL')
+db.pragma('foreign_keys = ON')
+db.pragma('busy_timeout = 5000')
+
+db.exec(`
+CREATE TABLE IF NOT EXISTS users (
+    id            INTEGER PRIMARY KEY,
+    username      TEXT    NOT NULL UNIQUE,
+    password_hash TEXT    NOT NULL,
+    created_at    INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS sessions (
+    id         TEXT    PRIMARY KEY,
+    user_id    INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    created_at INTEGER NOT NULL,
+    expires_at INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS sessions_expires ON sessions(expires_at);
+
+CREATE TABLE IF NOT EXISTS tokens (
+    id           INTEGER PRIMARY KEY,
+    name         TEXT    NOT NULL,
+    -- Nur der Hash. Der Token selbst wird genau einmal gezeigt und ist danach
+    -- auch fuer uns nicht mehr lesbar — wer ihn verliert, legt einen neuen an.
+    hash         TEXT    NOT NULL UNIQUE,
+    -- Optionale Fessel: dieser Token darf nur unterhalb dieses Praefix
+    -- schreiben. Leer heisst ueberall.
+    prefix       TEXT    NOT NULL DEFAULT '',
+    can_delete   INTEGER NOT NULL DEFAULT 0,
+    created_at   INTEGER NOT NULL,
+    last_used_at INTEGER
+);
+
+CREATE TABLE IF NOT EXISTS media (
+    id         INTEGER PRIMARY KEY,
+    -- Der Pfad IST der Schluessel. Fuer das Fotostudio ist das der ganze
+    -- Punkt: vehicles/adder.webp bleibt vehicles/adder.webp, damit die
+    -- Vorlage im Handy {model}.webp lauten kann und niemand eine
+    -- Uebersetzungstabelle mitschleppen muss.
+    path       TEXT    NOT NULL UNIQUE,
+    size       INTEGER NOT NULL,
+    sha256     TEXT    NOT NULL,
+    mime       TEXT    NOT NULL,
+    token_id   INTEGER REFERENCES tokens(id) ON DELETE SET NULL,
+    created_at INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS media_created ON media(created_at DESC);
+`)
+
+export type User = {
+    id: number
+    username: string
+    password_hash: string
+    created_at: number
+}
+
+export type Token = {
+    id: number
+    name: string
+    hash: string
+    prefix: string
+    can_delete: number
+    created_at: number
+    last_used_at: number | null
+}
+
+export type Media = {
+    id: number
+    path: string
+    size: number
+    sha256: string
+    mime: string
+    token_id: number | null
+    created_at: number
+    updated_at: number
+}
+
+export const now = () => Date.now()
+
+/** Abgelaufene Sitzungen wegraeumen. Beim Start und danach stuendlich —
+ *  sonst waechst die Tabelle ewig, und niemand merkt es. */
+export function pruneSessions() {
+    db.prepare('DELETE FROM sessions WHERE expires_at < ?').run(now())
+}

server/src/index.ts

@@ -0,0 +1,168 @@
+// Der Einstiegspunkt.
+//
+// ZWEI HOSTNAMEN, EIN PROZESS. Kommt eine Anfrage unter FILES_HOST herein,
+// gibt es nur Dateien — kein Dashboard, keine API, kein Anmeldeformular. Das
+// hat zwei Gruende:
+//
+//   1. Die oeffentliche Adresse bleibt huebsch. Das Handy fragt
+//      https://fivecdn.d4rkst3r.de/vehicles/adder.webp ab und nicht
+//      irgendein /f/-Praefix — die Vorlage lautet weiterhin schlicht
+//      {model}.webp.
+//   2. Der Name, der im Internet steht und den jeder Spieler kennt, hat
+//      ueberhaupt keine Angriffsflaeche. Es gibt dort nichts anzumelden.
+//
+// Unter dem anderen Namen laeuft das Dashboard samt API, und die Dateien sind
+// dort zusaetzlich unter /f/ erreichbar — praktisch fuer die Galerie, wenn
+// jemand den zweiten Hostnamen noch nicht eingerichtet hat.
+
+import { createReadStream } from 'node:fs'
+import { stat } from 'node:fs/promises'
+import { fileURLToPath } from 'node:url'
+import { join } from 'node:path'
+import { serve } from '@hono/node-server'
+import { Hono } from 'hono'
+import { logger } from 'hono/logger'
+import { config } from './config.js'
+import { ensureAdmin } from './auth.js'
+import { pruneSessions } from './db.js'
+import { absolutePath, checkPath, mimeFor } from './storage.js'
+import { uploadRoutes } from './routes/upload.js'
+import { dashRoutes } from './routes/dash.js'
+
+const app = new Hono()
+
+if (config.dev) app.use('*', logger())
+
+// -------------------------------------------------------- Dateien ausliefern
+
+/** Liefert eine Datei aus, mit ETag und Bereichsanfragen.
+ *
+ *  Bereichsanfragen sind kein Luxus: ohne sie kann ein Browser in einem Video
+ *  nicht springen, und ein abgebrochener Download faengt von vorn an. */
+async function serveFile(c: any, rawPath: string) {
+    let path: string
+    try {
+        path = checkPath(decodeURIComponent(rawPath))
+    } catch {
+        return c.text('nicht gefunden', 404)
+    }
+
+    const absolute = absolutePath(path)
+    let info
+    try {
+        info = await stat(absolute)
+        if (!info.isFile()) return c.text('nicht gefunden', 404)
+    } catch {
+        return c.text('nicht gefunden', 404)
+    }
+
+    const etag = `"${info.size.toString(16)}-${info.mtimeMs.toString(16)}"`
+    const headers: Record<string, string> = {
+        'Content-Type': mimeFor(path),
+        'Cache-Control': 'public, max-age=300',
+        ETag: etag,
+        'Last-Modified': info.mtime.toUTCString(),
+        'Accept-Ranges': 'bytes',
+        // Kein Verlassen auf den Dateinamen: der Browser soll nicht raten,
+        // was er da vor sich hat.
+        'X-Content-Type-Options': 'nosniff',
+    }
+
+    if (c.req.header('if-none-match') === etag) return c.body(null, 304, headers)
+    if (c.req.method === 'HEAD') {
+        return c.body(null, 200, { ...headers, 'Content-Length': String(info.size) })
+    }
+
+    const range = /^bytes=(\d*)-(\d*)$/.exec(c.req.header('range') ?? '')
+    if (range) {
+        const start = range[1] ? Number(range[1]) : 0
+        const end = range[2] ? Number(range[2]) : info.size - 1
+        if (start >= info.size || end >= info.size || start > end) {
+            return c.body(null, 416, { 'Content-Range': `bytes */${info.size}` })
+        }
+        return c.body(createReadStream(absolute, { start, end }) as any, 206, {
+            ...headers,
+            'Content-Range': `bytes ${start}-${end}/${info.size}`,
+            'Content-Length': String(end - start + 1),
+        })
+    }
+
+    return c.body(createReadStream(absolute) as any, 200, {
+        ...headers,
+        'Content-Length': String(info.size),
+    })
+}
+
+// ------------------------------------------------------------ Der Dateiwirt
+
+app.use('*', async (c, next) => {
+    const host = (c.req.header('host') ?? '').split(':')[0]?.toLowerCase()
+    if (host !== config.filesHost.split(':')[0]?.toLowerCase()) return next()
+
+    if (c.req.method !== 'GET' && c.req.method !== 'HEAD') {
+        return c.text('hier gibt es nur Dateien', 405)
+    }
+    if (c.req.path === '/') return c.text('d4rk_media', 200)
+
+    return serveFile(c, c.req.path.slice(1))
+})
+
+// ------------------------------------------------------- Dashboard und API
+
+app.get('/health', (c) => c.json({ ok: true }))
+
+app.route('/api', uploadRoutes)
+app.route('/api/dash', dashRoutes)
+
+app.get('/f/*', (c) => serveFile(c, c.req.path.slice(3)))
+
+// Die gebaute Oberflaeche. Alles, was keine API ist und keine Datei, bekommt
+// index.html — sonst endet ein Neuladen auf /tokens im 404 statt im Router.
+// fileURLToPath und nicht .pathname: unter Windows liefert letzteres
+// "/C:/..." und jedes stat() darauf schlaegt fehl.
+const webDir = fileURLToPath(new URL('../web/', import.meta.url))
+app.get('*', async (c) => {
+    if (c.req.path.startsWith('/api/')) return c.json({ error: 'unbekannt' }, 404)
+
+    const candidate = c.req.path === '/' ? '/index.html' : c.req.path
+    try {
+        const target = join(webDir, candidate.replace(/^\//, ''))
+        const info = await stat(target)
+        if (info.isFile()) {
+            return c.body(createReadStream(target) as any, 200, {
+                'Content-Type': mimeFor(candidate),
+                'Cache-Control': candidate.includes('/assets/')
+                    ? 'public, max-age=31536000, immutable'
+                    : 'no-cache',
+            })
+        }
+    } catch {
+        /* faellt unten auf index.html */
+    }
+
+    try {
+        return c.body(createReadStream(join(webDir, 'index.html')) as any, 200, {
+            'Content-Type': 'text/html; charset=utf-8',
+            'Cache-Control': 'no-cache',
+        })
+    } catch {
+        return c.text(
+            'Die Oberflaeche ist nicht gebaut. Der Dienst laeuft trotzdem — ' +
+                'die API steht unter /api.',
+            200,
+        )
+    }
+})
+
+// --------------------------------------------------------------------- Start
+
+ensureAdmin()
+pruneSessions()
+setInterval(pruneSessions, 3600_000).unref()
+
+serve({ fetch: app.fetch, port: config.port }, (info) => {
+    console.log(`[d4rk_media] Port ${info.port}`)
+    console.log(`[d4rk_media] Dateien oeffentlich unter ${config.publicUrl}`)
+    console.log(`[d4rk_media] Dateiwirt hoert auf Host "${config.filesHost}"`)
+    console.log(`[d4rk_media] Daten in ${config.dataDir}`)
+})

server/src/routes/dash.ts

@@ -0,0 +1,247 @@
+// Die Schnittstelle fuer das Dashboard.
+//
+// Eine Regel zieht sich durch alles hier: JEDE Antwort sagt, was passiert ist
+// — auch die erfolgreiche. Bei Fivemanage hat genau das gefehlt, und das
+// Ergebnis waren neunzehn gleichnamige Organisationen, weil ein Knopf ohne
+// Rueckmeldung wie ein kaputter Knopf aussieht.
+
+import { Hono } from 'hono'
+import { deleteCookie, getCookie, setCookie } from 'hono/cookie'
+import { config } from '../config.js'
+import { db, now, pruneSessions, type Media, type Token, type User } from '../db.js'
+import {
+    SESSION_COOKIE,
+    createSession,
+    destroySession,
+    generateToken,
+    hashPassword,
+    tokenHash,
+    userForSession,
+    verifyPassword,
+} from '../auth.js'
+import { checkPath, deleteFile, publicUrlFor, PathError } from '../storage.js'
+
+type Vars = { user: User }
+
+export const dashRoutes = new Hono<{ Variables: Vars }>()
+
+// ---------------------------------------------------------------- Anmeldung
+
+dashRoutes.post('/auth/login', async (c) => {
+    const { username, password } = await c.req.json<{
+        username?: string
+        password?: string
+    }>()
+
+    if (!username || !password) {
+        return c.json({ error: 'Benutzername und Passwort noetig' }, 400)
+    }
+
+    const user = db.prepare('SELECT * FROM users WHERE username = ?').get(username) as
+        | User
+        | undefined
+
+    // Bewusst dieselbe Meldung fuer "kein solcher Benutzer" und "falsches
+    // Passwort": alles andere verraet, welche Namen es gibt.
+    if (!user || !verifyPassword(password, user.password_hash)) {
+        return c.json({ error: 'Benutzername oder Passwort stimmt nicht' }, 401)
+    }
+
+    const session = createSession(user.id)
+    setCookie(c, SESSION_COOKIE, session.id, {
+        httpOnly: true,
+        secure: !config.dev,
+        sameSite: 'Lax',
+        path: '/',
+        expires: new Date(session.expiresAt),
+    })
+
+    return c.json({ user: { id: user.id, username: user.username } })
+})
+
+dashRoutes.post('/auth/logout', (c) => {
+    const sid = getCookie(c, SESSION_COOKIE)
+    if (sid) destroySession(sid)
+    deleteCookie(c, SESSION_COOKIE, { path: '/' })
+    return c.json({ ok: true })
+})
+
+dashRoutes.get('/auth/me', (c) => {
+    const user = userForSession(getCookie(c, SESSION_COOKIE))
+    if (!user) return c.json({ error: 'nicht angemeldet' }, 401)
+    return c.json({ user: { id: user.id, username: user.username } })
+})
+
+// Ab hier gilt: angemeldet oder nichts.
+dashRoutes.use('*', async (c, next) => {
+    const user = userForSession(getCookie(c, SESSION_COOKIE))
+    if (!user) return c.json({ error: 'nicht angemeldet' }, 401)
+    c.set('user', user)
+    await next()
+})
+
+dashRoutes.post('/auth/password', async (c) => {
+    const { current, next: fresh } = await c.req.json<{
+        current?: string
+        next?: string
+    }>()
+    const user = c.get('user')
+
+    if (!current || !fresh) return c.json({ error: 'beide Passwoerter noetig' }, 400)
+    if (fresh.length < 8) return c.json({ error: 'mindestens 8 Zeichen' }, 400)
+    if (!verifyPassword(current, user.password_hash)) {
+        return c.json({ error: 'aktuelles Passwort stimmt nicht' }, 401)
+    }
+
+    db.prepare('UPDATE users SET password_hash = ? WHERE id = ?').run(
+        hashPassword(fresh),
+        user.id,
+    )
+    // Alle anderen Sitzungen beenden — ein Passwortwechsel, der alte
+    // Anmeldungen weiterlaufen laesst, ist keiner.
+    db.prepare('DELETE FROM sessions WHERE user_id = ? AND id != ?').run(
+        user.id,
+        getCookie(c, SESSION_COOKIE),
+    )
+    return c.json({ ok: true })
+})
+
+// ------------------------------------------------------------------- Medien
+
+dashRoutes.get('/media', (c) => {
+    const query = c.req.query('query')?.trim() ?? ''
+    const limit = Math.min(Number(c.req.query('limit') ?? 60) || 60, 200)
+    const offset = Math.max(Number(c.req.query('offset') ?? 0) || 0, 0)
+
+    const where = query ? 'WHERE path LIKE ?' : ''
+    const params = query ? [`%${query}%`] : []
+
+    const total = db.prepare(`SELECT COUNT(*) AS n FROM media ${where}`).get(...params) as {
+        n: number
+    }
+    const rows = db
+        .prepare(
+            `SELECT * FROM media ${where} ORDER BY updated_at DESC LIMIT ? OFFSET ?`,
+        )
+        .all(...params, limit, offset) as Media[]
+
+    return c.json({
+        total: total.n,
+        limit,
+        offset,
+        items: rows.map((row) => ({ ...row, url: publicUrlFor(row.path) })),
+    })
+})
+
+dashRoutes.delete('/media/:id', async (c) => {
+    const id = Number(c.req.param('id'))
+    const row = db.prepare('SELECT * FROM media WHERE id = ?').get(id) as Media | undefined
+    if (!row) return c.json({ error: 'nicht gefunden' }, 404)
+
+    await deleteFile(row.path)
+    db.prepare('DELETE FROM media WHERE id = ?').run(id)
+    return c.json({ deleted: row.path })
+})
+
+/** Mehrere auf einmal — bei 900 Fahrzeugbildern will niemand 900 Mal klicken. */
+dashRoutes.post('/media/delete', async (c) => {
+    const { ids } = await c.req.json<{ ids?: number[] }>()
+    if (!Array.isArray(ids) || ids.length === 0) {
+        return c.json({ error: 'keine Auswahl' }, 400)
+    }
+
+    const select = db.prepare('SELECT * FROM media WHERE id = ?')
+    const remove = db.prepare('DELETE FROM media WHERE id = ?')
+    const deleted: string[] = []
+
+    for (const id of ids) {
+        const row = select.get(id) as Media | undefined
+        if (!row) continue
+        await deleteFile(row.path)
+        remove.run(id)
+        deleted.push(row.path)
+    }
+
+    return c.json({ deleted, count: deleted.length })
+})
+
+dashRoutes.get('/stats', (c) => {
+    const media = db
+        .prepare('SELECT COUNT(*) AS files, COALESCE(SUM(size), 0) AS bytes FROM media')
+        .get() as { files: number; bytes: number }
+    const tokens = db.prepare('SELECT COUNT(*) AS n FROM tokens').get() as { n: number }
+
+    // Die groessten Ordner — die erste Frage bei "wo ist mein Platz hin".
+    const folders = db
+        .prepare(
+            `SELECT
+                 CASE WHEN instr(path, '/') > 0
+                      THEN substr(path, 1, instr(path, '/') - 1)
+                      ELSE '(Wurzel)' END AS folder,
+                 COUNT(*) AS files,
+                 SUM(size) AS bytes
+             FROM media GROUP BY folder ORDER BY bytes DESC LIMIT 10`,
+        )
+        .all() as { folder: string; files: number; bytes: number }[]
+
+    return c.json({ ...media, tokens: tokens.n, folders, publicUrl: config.publicUrl })
+})
+
+// ------------------------------------------------------------------- Tokens
+
+dashRoutes.get('/tokens', (c) => {
+    const rows = db
+        .prepare('SELECT id, name, prefix, can_delete, created_at, last_used_at FROM tokens ORDER BY created_at DESC')
+        .all() as Omit<Token, 'hash'>[]
+    return c.json({ items: rows })
+})
+
+dashRoutes.post('/tokens', async (c) => {
+    const { name, prefix, canDelete } = await c.req.json<{
+        name?: string
+        prefix?: string
+        canDelete?: boolean
+    }>()
+
+    if (!name?.trim()) return c.json({ error: 'Name fehlt' }, 400)
+
+    // Das Praefix ist ein Pfadanfang und wird nach denselben Regeln geprueft.
+    let cleanPrefix = ''
+    if (prefix?.trim()) {
+        try {
+            cleanPrefix = checkPath(prefix.trim().replace(/\/+$/, ''))
+        } catch (err) {
+            if (err instanceof PathError) return c.json({ error: err.message }, 400)
+            throw err
+        }
+    }
+
+    const token = generateToken()
+    const info = db
+        .prepare(
+            `INSERT INTO tokens (name, hash, prefix, can_delete, created_at)
+             VALUES (?, ?, ?, ?, ?)`,
+        )
+        .run(name.trim(), tokenHash(token), cleanPrefix, canDelete ? 1 : 0, now())
+
+    // Der Klartext geht genau EINMAL raus. Danach steht nur noch der Hash in
+    // der Datenbank, und auch wir koennen ihn nicht mehr zeigen.
+    return c.json({
+        id: Number(info.lastInsertRowid),
+        name: name.trim(),
+        prefix: cleanPrefix,
+        canDelete: Boolean(canDelete),
+        token,
+    })
+})
+
+dashRoutes.delete('/tokens/:id', (c) => {
+    const info = db.prepare('DELETE FROM tokens WHERE id = ?').run(Number(c.req.param('id')))
+    if (info.changes === 0) return c.json({ error: 'nicht gefunden' }, 404)
+    return c.json({ ok: true })
+})
+
+dashRoutes.post('/maintenance/prune-sessions', (c) => {
+    pruneSessions()
+    return c.json({ ok: true })
+})

server/src/routes/upload.ts

@@ -0,0 +1,225 @@
+// Die Schnittstelle fuer Skripte: hochladen und wieder loeschen.
+//
+// Das ist der Teil, den der FiveM-Server anspricht — deshalb ist er stur
+// einfach gehalten. Ein Aufruf, ein Token, eine Antwort mit der fertigen URL.
+//
+//     POST /api/upload
+//     Authorization: Bearer d4rk_...
+//     X-Path: vehicles/adder.webp
+//     X-Encoding: base64
+//     <Rumpf>
+//
+// DREI FORMEN FUER DEN RUMPF, und der Grund fuer die dritte ist FiveM:
+//
+//   multipart/form-data   Feld "file" — so laedt das Dashboard hoch
+//   X-Encoding: base64    Base64-Text — so laedt Lua hoch
+//   sonst                 rohe Bytes
+//
+// PerformHttpRequest schickt einen Lua-String; rohe Bytes ueberstehen den Weg
+// nicht zuverlaessig. Im Fotostudio kommt das Bild ohnehin als Data-URL aus
+// dem NUI, ist also schon Base64 — der Umweg ist damit keiner.
+
+import { Hono } from 'hono'
+import type { Context } from 'hono'
+import { config } from '../config.js'
+import { db, now, type Media, type Token } from '../db.js'
+import { tokenAllows, tokenFromHeader } from '../auth.js'
+import {
+    PathError,
+    checkPath,
+    deleteFile,
+    extensionFor,
+    fileExists,
+    mimeFor,
+    publicUrlFor,
+    sha256,
+    writeFileAtomic,
+} from '../storage.js'
+
+type Vars = { token: Token }
+
+export const uploadRoutes = new Hono<{ Variables: Vars }>()
+
+uploadRoutes.use('*', async (c, next) => {
+    const token = tokenFromHeader(c.req.header('authorization'))
+    if (!token) {
+        return c.json({ error: 'Token fehlt oder ist unbekannt' }, 401)
+    }
+    c.set('token', token)
+    await next()
+})
+
+/** Den Rumpf einsammeln, in welcher der drei Formen er auch kommt. */
+async function readBody(
+    c: Context<{ Variables: Vars }>,
+): Promise<{ data: Buffer; path?: string; filename?: string }> {
+    const contentType = c.req.header('content-type') ?? ''
+
+    if (contentType.includes('multipart/form-data')) {
+        const form = await c.req.parseBody()
+        const file = form['file']
+        if (!(file instanceof File)) {
+            throw new Error('Feld "file" fehlt im Formular')
+        }
+        return {
+            data: Buffer.from(await file.arrayBuffer()),
+            path: typeof form['path'] === 'string' ? form['path'] : undefined,
+            filename: file.name,
+        }
+    }
+
+    const raw = Buffer.from(await c.req.arrayBuffer())
+
+    if (/base64/i.test(c.req.header('x-encoding') ?? '')) {
+        // Data-URLs kommen mit Vorspann ("data:image/webp;base64,"). Den
+        // abzuschneiden ist freundlicher, als den Aufrufer dazu zu zwingen.
+        const text = raw.toString('utf8').replace(/^data:[^,]*,/, '')
+        return { data: Buffer.from(text, 'base64') }
+    }
+
+    return { data: raw }
+}
+
+uploadRoutes.post('/upload', async (c) => {
+    const token = c.get('token')
+
+    // Erst die angekuendigte Groesse pruefen, damit ein zu grosser Upload
+    // abgewiesen wird, BEVOR er im Speicher liegt.
+    const announced = Number(c.req.header('content-length') ?? 0)
+    if (announced > config.maxUploadBytes) {
+        return c.json(
+            { error: `zu gross: ${announced} > ${config.maxUploadBytes} Bytes` },
+            413,
+        )
+    }
+
+    let body: Awaited<ReturnType<typeof readBody>>
+    try {
+        body = await readBody(c)
+    } catch (err) {
+        return c.json({ error: err instanceof Error ? err.message : String(err) }, 400)
+    }
+
+    const { data } = body
+    if (data.length === 0) return c.json({ error: 'Rumpf ist leer' }, 400)
+    if (data.length > config.maxUploadBytes) {
+        return c.json(
+            { error: `zu gross: ${data.length} > ${config.maxUploadBytes} Bytes` },
+            413,
+        )
+    }
+
+    const digest = sha256(data)
+
+    // Der Pfad: ausdruecklich gewuenscht, oder aus dem Hash gebaut. Der
+    // gewuenschte hat Vorrang und wird NICHT zurechtgebogen.
+    const wanted = c.req.header('x-path') ?? body.path ?? body.filename
+    let path: string
+    try {
+        path = wanted
+            ? checkPath(wanted)
+            : checkPath(
+                  `uploads/${digest.slice(0, 2)}/${digest}.${extensionFor(
+                      c.req.header('x-mime') ?? 'application/octet-stream',
+                  )}`,
+              )
+    } catch (err) {
+        if (err instanceof PathError) return c.json({ error: err.message }, 400)
+        throw err
+    }
+
+    if (!tokenAllows(token, path)) {
+        return c.json(
+            { error: `dieser Token darf nur unter "${token.prefix}/" schreiben` },
+            403,
+        )
+    }
+
+    const existing = db.prepare('SELECT * FROM media WHERE path = ?').get(path) as
+        | Media
+        | undefined
+
+    // Ueberschreiben ist der Normalfall: ein neu aufgenommenes Fahrzeugbild
+    // soll das alte ersetzen, sonst braeuchte jeder zweite Lauf einen anderen
+    // Namen. Wer das nicht will, sagt es.
+    const overwrite = (c.req.header('x-overwrite') ?? 'true').toLowerCase() !== 'false'
+    if (existing && !overwrite) {
+        return c.json({ error: 'Pfad ist belegt', path, url: publicUrlFor(path) }, 409)
+    }
+
+    const mime = c.req.header('x-mime') ?? mimeFor(path)
+
+    try {
+        await writeFileAtomic(path, data)
+    } catch (err) {
+        console.error('[upload] Schreiben fehlgeschlagen:', err)
+        return c.json({ error: 'Schreiben fehlgeschlagen' }, 500)
+    }
+
+    const timestamp = now()
+    if (existing) {
+        db.prepare(
+            `UPDATE media SET size = ?, sha256 = ?, mime = ?, token_id = ?, updated_at = ?
+             WHERE id = ?`,
+        ).run(data.length, digest, mime, token.id, timestamp, existing.id)
+    } else {
+        db.prepare(
+            `INSERT INTO media (path, size, sha256, mime, token_id, created_at, updated_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?)`,
+        ).run(path, data.length, digest, mime, token.id, timestamp, timestamp)
+    }
+
+    return c.json({
+        url: publicUrlFor(path),
+        path,
+        size: data.length,
+        sha256: digest,
+        mime,
+        replaced: Boolean(existing),
+    })
+})
+
+/** Loeschen ueber den Pfad — Skripte kennen den Pfad, nicht unsere ID. */
+uploadRoutes.delete('/media/*', async (c) => {
+    const token = c.get('token')
+    if (!token.can_delete) {
+        return c.json({ error: 'dieser Token darf nicht loeschen' }, 403)
+    }
+
+    let path: string
+    try {
+        path = checkPath(decodeURIComponent(c.req.path.replace(/^\/media\//, '')))
+    } catch (err) {
+        if (err instanceof PathError) return c.json({ error: err.message }, 400)
+        throw err
+    }
+
+    if (!tokenAllows(token, path)) {
+        return c.json({ error: 'ausserhalb des erlaubten Bereichs' }, 403)
+    }
+    if (!(await fileExists(path))) return c.json({ error: 'nicht gefunden', path }, 404)
+
+    await deleteFile(path)
+    db.prepare('DELETE FROM media WHERE path = ?').run(path)
+    return c.json({ deleted: path })
+})
+
+/** Nachsehen, ob es etwas schon gibt — damit ein Lauf "nur fehlende"
+ *  beantworten kann, ohne 900 Bilder hochzuladen. */
+uploadRoutes.get('/exists/*', (c) => {
+    let path: string
+    try {
+        path = checkPath(decodeURIComponent(c.req.path.replace(/^\/exists\//, '')))
+    } catch {
+        return c.json({ exists: false }, 200)
+    }
+    const row = db.prepare('SELECT size, sha256, updated_at FROM media WHERE path = ?').get(
+        path,
+    ) as Pick<Media, 'size' | 'sha256' | 'updated_at'> | undefined
+
+    return c.json(
+        row
+            ? { exists: true, path, url: publicUrlFor(path), ...row }
+            : { exists: false, path },
+    )
+})

server/src/storage.ts

@@ -0,0 +1,131 @@
+// Dateien auf der Platte.
+//
+// Der Pfad kommt vom Aufrufer — beim Fotostudio ist das genau der Punkt,
+// vehicles/adder.webp soll vehicles/adder.webp bleiben. Damit ist er auch die
+// gefaehrlichste Eingabe, die dieser Dienst kennt: ein durchgelassenes ".."
+// schreibt irgendwohin auf dem Wirt.
+//
+// Deshalb wird hier nicht bereinigt, sondern ABGELEHNT. Ein Pfad, der nicht
+// den Regeln entspricht, wird nicht zurechtgebogen — sonst landet eine Datei
+// unter einem anderen Namen als dem, den der Aufrufer erwartet, und niemand
+// merkt es, bis das Bild fehlt.
+
+import { createHash } from 'node:crypto'
+import { mkdir, rename, rm, stat, writeFile } from 'node:fs/promises'
+import { dirname, join, resolve, sep } from 'node:path'
+import { config } from './config.js'
+
+/** Ein Segment: beginnt mit Buchstabe oder Ziffer, danach auch Punkt, Strich
+ *  und Unterstrich. Damit sind "..", versteckte Dateien und alles mit
+ *  Schraegstrich, Backslash oder Steuerzeichen von vornherein draussen. */
+const SEGMENT = /^[A-Za-z0-9][A-Za-z0-9._-]*$/
+
+export const MAX_PATH_LENGTH = 200
+export const MAX_DEPTH = 8
+
+export class PathError extends Error {}
+
+/** Prueft den Pfad und gibt ihn normalisiert zurueck. Wirft PathError. */
+export function checkPath(raw: string): string {
+    const path = raw.trim().replace(/^\/+/, '')
+
+    if (!path) throw new PathError('Pfad ist leer')
+    if (path.length > MAX_PATH_LENGTH) {
+        throw new PathError(`Pfad laenger als ${MAX_PATH_LENGTH} Zeichen`)
+    }
+
+    const segments = path.split('/')
+    if (segments.length > MAX_DEPTH) {
+        throw new PathError(`mehr als ${MAX_DEPTH} Ebenen`)
+    }
+
+    for (const segment of segments) {
+        if (!SEGMENT.test(segment)) {
+            throw new PathError(
+                `"${segment}" ist als Pfadteil nicht erlaubt ` +
+                    '(Buchstaben, Ziffern, Punkt, Strich, Unterstrich; ' +
+                    'nicht mit Punkt beginnend)',
+            )
+        }
+    }
+
+    // Guertel und Hosentraeger: selbst wenn oben je eine Luecke waere, muss
+    // das Ergebnis unterhalb des Datenordners liegen.
+    const absolute = resolve(config.filesDir, path)
+    if (absolute !== config.filesDir && !absolute.startsWith(config.filesDir + sep)) {
+        throw new PathError('Pfad zeigt aus dem Datenordner heraus')
+    }
+
+    return path
+}
+
+const MIME: Record<string, string> = {
+    webp: 'image/webp',
+    png: 'image/png',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    gif: 'image/gif',
+    svg: 'image/svg+xml',
+    avif: 'image/avif',
+    mp4: 'video/mp4',
+    webm: 'video/webm',
+    mp3: 'audio/mpeg',
+    ogg: 'audio/ogg',
+    wav: 'audio/wav',
+    pdf: 'application/pdf',
+    json: 'application/json',
+    txt: 'text/plain; charset=utf-8',
+}
+
+export function mimeFor(path: string): string {
+    const ext = path.split('.').pop()?.toLowerCase() ?? ''
+    return MIME[ext] ?? 'application/octet-stream'
+}
+
+export function extensionFor(mime: string): string {
+    const base = mime.split(';')[0]?.trim().toLowerCase()
+    for (const [ext, value] of Object.entries(MIME)) {
+        if (value.split(';')[0] === base) return ext
+    }
+    return 'bin'
+}
+
+export const sha256 = (data: Buffer) => createHash('sha256').update(data).digest('hex')
+
+export const absolutePath = (path: string) => join(config.filesDir, path)
+
+/** Schreibt die Datei.
+ *
+ *  Erst daneben, dann umbenennen: ein Ueberschreiben ist damit entweder ganz
+ *  passiert oder gar nicht. Sonst koennte ein abgebrochener Upload das alte
+ *  Bild durch ein halbes ersetzen — und halbe Bilder sehen im Handy aus wie
+ *  ein Fehler im Handy. */
+export async function writeFileAtomic(path: string, data: Buffer): Promise<void> {
+    const target = absolutePath(path)
+    await mkdir(dirname(target), { recursive: true })
+
+    const temp = `${target}.${process.pid}.${Date.now()}.tmp`
+    try {
+        await writeFile(temp, data)
+        await rename(temp, target)
+    } catch (err) {
+        await rm(temp, { force: true }).catch(() => {})
+        throw err
+    }
+}
+
+export async function deleteFile(path: string): Promise<void> {
+    await rm(absolutePath(path), { force: true })
+}
+
+export async function fileExists(path: string): Promise<boolean> {
+    try {
+        await stat(absolutePath(path))
+        return true
+    } catch {
+        return false
+    }
+}
+
+/** Die oeffentliche Adresse einer Datei. */
+export const publicUrlFor = (path: string) => `${config.publicUrl}/${path}`

server/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "lib": ["ES2023"],
+    "types": ["node"],
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "verbatimModuleSyntax": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*.ts"]
+}