feat(office): Dokumente am Telefon als PDF ansehen statt bearbeiten

Am Finger öffnet ein Office-Dokument jetzt das gewandelte PDF im eigenen
Betrachter; "Edit" daneben führt trotzdem in den Editor. Mit Maus ändert
sich nichts.

Der Web-Editor ist eine vollständige Textverarbeitung – zwischen seinen
Leisten bleibt auf 400 Pixeln vom Dokument ein Rechteck. Collabora und
OnlyOffice verhalten sich gleich; deshalb kein besserer Bedienmodus,
sondern ein anderes Werkzeug. Gewandelt wird von dem Server, der auch
bearbeitet: Sonst sähe man unterwegs ein LibreOffice-Layout eines
Dokuments, für das man OnlyOffice gewählt hat.

Je Dokument gibt es GENAU EIN PDF, und das ist keine Frage des
Aufräumens, sondern des Schlüssels: previews/<id>.pdf trägt die Fassung
nicht im Namen, eine neue Fassung überschreibt. files.preview_version
sagt, ob das Abgelegte noch passt.

Sicherheit: Die Adresse, die OnlyOffice zurückgibt, wird von uns
abgerufen – der Wähler des Transports lässt nur OFFICE_ALLOWED_HOSTS zu,
zusätzlich eine ausdrückliche Prüfung mit Test. JWT-Signatur (HS256) für
die eigene API des Dokumentenservers. Fremde Kennung 404, ohne Anmeldung
401. Das Ergebnis muss mit %PDF- beginnen, sonst landete eine
Fehlerseite im Zwischenspeicher.

Gemessen gegen einen echten OnlyOffice-Server im Docker-Netz:
  erster Abruf 1,05 s -> zweiter 0,009 s
  erneut hochgeladen -> Fassung 2, preview_version 2, weiterhin 1 Datei
  GC: herrenloses PDF von vorgestern weg, echtes bleibt
  endgültig gelöscht -> PDF weg; Papierkorb -> PDF bleibt
  ohne Anmeldung 401, fremde Kennung 404, Nicht-Office 415

Dazu im Admin-Bereich neu: Platzbedarf der abgeleiteten Daten
(Vorschaubilder, PDFs, Profilbilder). Sie zählen gegen kein Kontingent –
ein Ordner, der wächst, ohne dass ihn jemand sieht, ist eine stille
Überraschung.

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

README.md

@@ -654,6 +654,35 @@ Abbild.
 > über `{"payload": …}`) kommt das Ergebnis. Der Schlüssel gehört also
 > gesetzt – sonst läuft die API offen.
 
+### Am Telefon: ansehen statt bearbeiten
+
+Tippt man auf ein Office-Dokument, öffnet sich am **Finger** nicht der Editor,
+sondern das Dokument als PDF im eigenen Betrachter. „Edit" in der Kopfzeile
+führt trotzdem hinein. Mit **Maus** ändert sich nichts.
+
+Der Grund ist keine Geschmacksfrage: Der Web-Editor ist eine vollständige
+Textverarbeitung, und zwischen Menüband, Formatleisten und
+Eigenschaftenbereich bleibt auf 400 Pixeln vom Dokument ein Rechteck übrig.
+Das gilt für Collabora wie für OnlyOffice – beide ausprobiert, dasselbe Bild.
+Unterwegs ist der Anlass fast immer *nachsehen*, und dafür ist ein PDF das
+bessere Werkzeug.
+
+Gewandelt wird von **demselben** Server, der auch bearbeitet: Wer OnlyOffice
+wegen der Treue zu MS-Office-Formaten nimmt, soll unterwegs nicht ein
+LibreOffice-Layout desselben Dokuments sehen.
+
+| | |
+|---|---|
+| Ablage | `previews/<datei-id>.pdf` – **eine** Datei je Dokument, wird überschrieben |
+| Gültigkeit | `files.preview_version`; neue Fassung ⇒ neu gewandelt |
+| Kontingent | zählt **nicht** mit – abgeleitet, niemand hat es hochgeladen |
+| Aufräumen | endgültiges Löschen nimmt es mit; der GC kennt den Ordner |
+| Grenze | über 100 MB wird nicht gewandelt (`413`), die Oberfläche bietet den Editor an |
+| Nur OnlyOffice | braucht `OFFICE_JWT_SECRET` – ohne Signatur `{"error":-8}` |
+
+Wie viel Platz das belegt, steht im Admin-Bereich unter *Audit* neben der
+Bereinigung, zusammen mit Vorschau- und Profilbildern.
+
 ### Welche Dateien, und wie gut
 
 Bearbeitet wird nur, was auf der **Positivliste** steht:

backend/cmd/aether/main.go

@@ -216,7 +216,7 @@ func main() {
 	var officeHandler *office.Handler
 	if cfg.OfficeEnabled() {
 		client, err := office.NewClient(cfg.OfficeProvider, cfg.OfficeURL, cfg.OfficePublicURL,
-			cfg.OfficeAllowedHosts, cfg.OfficeInsecureTLS)
+			cfg.OfficeAllowedHosts, cfg.OfficeInsecureTLS, cfg.OfficeJWTSecret)
 		if err != nil {
 			// Kein Fatal: Eine falsche Office-Adresse soll die Cloud nicht am
 			// Starten hindern. Dateien bleiben erreichbar, nur das Bearbeiten
@@ -449,6 +449,9 @@ func main() {
 		// Sitzung fuer den Office-Rahmen: Hier entsteht das WOPI-Token, im
 		// angemeldeten Zusammenhang.
 		r.Get("/office/session/{id}", officeHandler.Session)
+		// Dasselbe Dokument als PDF – zum Ansehen, ohne den Editor. Am
+		// Telefon der Normalfall.
+		r.Get("/files/{id}/preview.pdf", officeHandler.PreviewPDF)
 		r.Patch("/files/{id}/versioning", fileHandler.SetVersioning)
 		r.Get("/files/{id}/versions", fileHandler.ListVersions)
 		r.Get("/files/{id}/versions/{versionId}/download", fileHandler.DownloadVersion)
@@ -529,6 +532,9 @@ func main() {
 		r.Get("/admin/audit", adminHandler.ListAudit)
 		r.Get("/admin/audit/actions", adminHandler.ListAuditActions)
 		r.Post("/admin/gc", adminHandler.RunGC)
+		// Was Vorschaubilder, Profilbilder und gewandelte Dokumente belegen –
+		// Platz, der in keinem Kontingent auftaucht.
+		r.Get("/admin/storage/derived", adminHandler.DerivedStorage)
 		// Immer erreichbar, auch wenn OCR aus ist – der Handler antwortet dann
 		// mit enabled:false. Eine Route, die je nach Konfiguration 404 liefert,
 		// wäre für die Oberfläche nicht von einem Fehler zu unterscheiden.

backend/db/migrations/000020_office_preview.down.sql

@@ -0,0 +1 @@
+ALTER TABLE files DROP COLUMN IF EXISTS preview_version;

backend/db/migrations/000020_office_preview.up.sql

@@ -0,0 +1,9 @@
+-- Die Fassung, aus der das zwischengespeicherte PDF entstanden ist.
+--
+-- Der Blob heißt `previews/<datei-id>.pdf` – **ohne** Fassungsnummer im
+-- Namen. Damit kann es je Datei nie mehr als eine Vorschau geben: Eine neue
+-- Fassung überschreibt die alte, statt eine zweite danebenzulegen. Ob die
+-- vorhandene noch zum Inhalt passt, sagt diese Spalte.
+--
+-- 0 heißt "keine". Dateifassungen zählen ab 1.
+ALTER TABLE files ADD COLUMN IF NOT EXISTS preview_version INT NOT NULL DEFAULT 0;

backend/internal/admin/audit_handler.go

@@ -97,3 +97,24 @@ func (h *Handler) RunGC(w http.ResponseWriter, r *http.Request) {
 		"skipped_young": res.SkippedYoung,
 	})
 }
+
+// GET /api/v1/admin/storage/derived – Platzbedarf der abgeleiteten Daten.
+//
+// Getrennt vom Aufräumen, weil es eine Auskunft ist und keine Handlung: Man
+// soll nachsehen können, ohne etwas anzustoßen.
+func (h *Handler) DerivedStorage(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireAdmin(r); !ok {
+		response.Error(w, http.StatusForbidden, "admin required")
+		return
+	}
+	if h.gc == nil {
+		response.Error(w, http.StatusServiceUnavailable, "not available")
+		return
+	}
+	usage, err := h.gc.Derived(r.Context())
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "could not read storage")
+		return
+	}
+	response.JSON(w, http.StatusOK, usage)
+}

backend/internal/files/handler_trash.go

@@ -104,6 +104,10 @@ func (h *Handler) EmptyTrash(w http.ResponseWriter, r *http.Request) {
 	}
 	for _, id := range fileIDs {
 		_ = h.storage.Delete(r.Context(), "thumbs/"+id.String()+".jpg")
+		// Das als PDF gewandelte Office-Dokument. Es trägt denselben Inhalt
+		// wie die Datei – bleibt es liegen, überlebt der Inhalt das endgültige
+		// Löschen.
+		_ = h.storage.Delete(r.Context(), "previews/"+id.String()+".pdf")
 	}
 
 	log.Ctx(r.Context()).Info().
@@ -139,6 +143,7 @@ func (h *Handler) HardDelete(w http.ResponseWriter, r *http.Request) {
 		_ = h.storage.Delete(r.Context(), key)
 	}
 	_ = h.storage.Delete(r.Context(), "thumbs/"+id.String()+".jpg")
+	_ = h.storage.Delete(r.Context(), "previews/"+id.String()+".pdf")
 	h.logFile(r, audit.ActionHardDelete, id.String(), "", "permanently deleted from trash")
 	response.NoContent(w)
 }

backend/internal/files/store.go

@@ -533,3 +533,50 @@ func isUniqueViolation(err error) bool {
 	}
 	return false
 }
+
+// PreviewVersion sagt, aus welcher Fassung das zwischengespeicherte PDF
+// entstanden ist – 0 heißt: es gibt keins.
+//
+// Eine eigene kleine Abfrage statt einer Spalte in `fileCols`: Der Wert wird
+// an genau einer Stelle gebraucht und ginge sonst durch jeden Scan, jede
+// Liste und jede Suche mit.
+func (s *Store) PreviewVersion(ctx context.Context, id uuid.UUID) (int, error) {
+	var v int
+	err := s.db.QueryRow(ctx, `SELECT preview_version FROM files WHERE id = $1`, id).Scan(&v)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return 0, ErrNotFound
+	}
+	if err != nil {
+		return 0, fmt.Errorf("preview version: %w", err)
+	}
+	return v, nil
+}
+
+// SetPreviewVersion vermerkt, dass das abgelegte PDF zu dieser Fassung gehört.
+func (s *Store) SetPreviewVersion(ctx context.Context, id uuid.UUID, version int) error {
+	_, err := s.db.Exec(ctx, `UPDATE files SET preview_version = $2 WHERE id = $1`, id, version)
+	if err != nil {
+		return fmt.Errorf("set preview version: %w", err)
+	}
+	return nil
+}
+
+// FilesWithPreview liefert die Kennungen aller Dateien, zu denen ein PDF
+// abgelegt ist. Der GC braucht das: Ohne diese Liste hielte er jedes
+// Vorschau-PDF für herrenlos und löschte es nach einem Tag weg.
+func (s *Store) FilesWithPreview(ctx context.Context) ([]string, error) {
+	rows, err := s.db.Query(ctx, `SELECT id::text FROM files WHERE preview_version > 0`)
+	if err != nil {
+		return nil, fmt.Errorf("files with preview: %w", err)
+	}
+	defer rows.Close()
+	var ids []string
+	for rows.Next() {
+		var id string
+		if err := rows.Scan(&id); err != nil {
+			return nil, err
+		}
+		ids = append(ids, id)
+	}
+	return ids, rows.Err()
+}

backend/internal/gc/gc.go

@@ -72,7 +72,7 @@ func (c *Collector) Run(ctx context.Context) (Result, error) {
 
 	// "tmp/" bleibt außen vor: Das gehört dem Upload-Pfad und wird dort
 	// aufgeräumt; ein GC, der dort mitmischt, zerrisse laufende Uploads.
-	for _, prefix := range []string{"users", "thumbs", "branding", "avatars"} {
+	for _, prefix := range []string{"users", "thumbs", "branding", "avatars", "previews"} {
 		err := c.storage.Walk(ctx, prefix, func(key string, info storage.FileInfo) error {
 			res.Scanned++
 			if referenced[key] {
@@ -153,6 +153,27 @@ func (c *Collector) referencedKeys(ctx context.Context) (map[string]bool, error)
 		return nil, fmt.Errorf("iterate file keys: %w", err)
 	}
 
+	// Die als PDF angesehenen Office-Dokumente. Ohne diesen Griff hielte der
+	// GC jedes Vorschau-PDF für herrenlos und löschte es nach einem Tag – der
+	// Fehler, der uns beim Logo und beim Favicon schon passiert ist.
+	prevRows, err := c.db.Query(ctx,
+		`SELECT id::text FROM files WHERE preview_version > 0`)
+	if err != nil {
+		return nil, fmt.Errorf("query preview keys: %w", err)
+	}
+	for prevRows.Next() {
+		var id string
+		if err := prevRows.Scan(&id); err != nil {
+			prevRows.Close()
+			return nil, fmt.Errorf("scan preview key: %w", err)
+		}
+		keys["previews/"+id+".pdf"] = true
+	}
+	prevRows.Close()
+	if err := prevRows.Err(); err != nil {
+		return nil, fmt.Errorf("iterate preview keys: %w", err)
+	}
+
 	// Logo und App-Symbol haben keine Zeile in files, sondern stehen in den
 	// Einstellungen. Ohne diese Abfrage hielte der GC sie für verwaist, sobald
 	// "branding" mit durchsucht wird – und löschte sie beim nächsten Lauf.
@@ -263,3 +284,38 @@ func (c *Collector) Start(ctx context.Context, onDone func(Result)) {
 		}
 	}()
 }
+
+// DerivedUsage: Wie viel Platz die **abgeleiteten** Daten belegen.
+//
+// Vorschaubilder, Profilbilder und die als PDF gewandelten Office-Dokumente
+// zählen nicht gegen das Kontingent eines Kontos – niemand hat sie
+// hochgeladen, und sie entstehen jederzeit neu. Platte kosten sie trotzdem,
+// und in der Anzeige „X von Y GB belegt" tauchen sie nicht auf.
+//
+// Genau deshalb steht die Zahl hier: Ein Ordner, der wächst, ohne dass ihn
+// irgendwo jemand sieht, ist eine stille Überraschung. Sichtbar ist sie eine
+// Größe, über die man entscheiden kann.
+type DerivedUsage struct {
+	Prefix string `json:"prefix"`
+	Files  int    `json:"files"`
+	Bytes  int64  `json:"bytes"`
+}
+
+// Derived zählt die abgeleiteten Ordner durch. Reines Lesen – dieser Aufruf
+// löscht nichts.
+func (c *Collector) Derived(ctx context.Context) ([]DerivedUsage, error) {
+	out := make([]DerivedUsage, 0, 3)
+	for _, prefix := range []string{"thumbs", "previews", "avatars"} {
+		u := DerivedUsage{Prefix: prefix}
+		err := c.storage.Walk(ctx, prefix, func(_ string, info storage.FileInfo) error {
+			u.Files++
+			u.Bytes += info.Size
+			return nil
+		})
+		if err != nil {
+			return nil, fmt.Errorf("walk %s: %w", prefix, err)
+		}
+		out = append(out, u)
+	}
+	return out, nil
+}

backend/internal/office/convert.go

@@ -0,0 +1,271 @@
+package office
+
+import (
+	"bytes"
+	"context"
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+)
+
+// Ein Dokument nach PDF wandeln – dafür, es *anzusehen*, statt es zu
+// bearbeiten.
+//
+// **Warum überhaupt:** Am Telefon ist der Office-Editor unbrauchbar. Er ist
+// eine vollständige Textverarbeitung; Menüband, Formatleisten und
+// Eigenschaftenbereich sind nicht Beiwerk, sondern das Produkt. Auf 400 Pixeln
+// bleibt für das Dokument übrig, was die Leisten nicht brauchen. Das gilt für
+// Collabora wie für OnlyOffice – Marc hat beide ausprobiert, mit demselben
+// Ergebnis. Ein PDF im eigenen Betrachter ist für „kurz nachsehen" das
+// bessere Werkzeug, und für „kurz nachsehen" ist man unterwegs da.
+//
+// **Warum derselbe Server, der auch bearbeitet:** Wer OnlyOffice wegen der
+// Treue zu MS-Office-Formaten nimmt, aber Collabora das PDF rechnen ließe,
+// sähe unterwegs ein LibreOffice-Layout desselben Dokuments. Zwei Geräte,
+// zwei Umbrüche – ausgerechnet bei Unterlagen, bei denen es auf die Seite
+// ankommt. Die Umwandlung gehört deshalb zu dem Anbieter, der auch bearbeitet.
+//
+// Die beiden Anbieter gehen dabei verschiedene Wege, und der Unterschied ist
+// grundsätzlich:
+//
+//   - **Collabora** nimmt die Datei entgegen und antwortet mit dem PDF. Ein
+//     Aufruf, keine Anmeldung.
+//   - **OnlyOffice** nimmt eine *Adresse* entgegen, holt die Datei selbst ab
+//     und antwortet mit einer Adresse, unter der das Ergebnis liegt. Also
+//     zwei Aufrufe, eine Signatur, und ein zweiter Ort, dem man nicht trauen
+//     darf (siehe unten).
+
+// convertTimeout: So lange darf eine Umwandlung dauern.
+//
+// Gemessen an dieser Anlage braucht ein gewöhnliches Textdokument etwa eine
+// Sekunde. Eine Minute ist keine Erwartung, sondern eine Notbremse: Hängt der
+// Office-Server, soll die Anfrage enden und nicht der Server mit ihr.
+const convertTimeout = 60 * time.Second
+
+// jwtLifetime: Wie lange die Signatur an OnlyOffice gilt. Sie wird für genau
+// einen Aufruf ausgestellt.
+const jwtLifetime = 2 * time.Minute
+
+// ConvertToPDF wandelt ein Dokument um.
+//
+// `src` ist die Adresse, unter der der Office-Server die Datei abholen kann –
+// nur OnlyOffice braucht sie. `body` sind die Bytes selbst – nur Collabora
+// braucht die. Der Aufrufer stellt beides bereit; welcher Weg genommen wird,
+// entscheidet der Anbieter, nicht der Aufrufer.
+func (c *Client) ConvertToPDF(ctx context.Context, ext, key, name, src string, body io.Reader) ([]byte, error) {
+	ctx, cancel := context.WithTimeout(ctx, convertTimeout)
+	defer cancel()
+
+	switch c.provider {
+	case "collabora":
+		return c.convertCollabora(ctx, name, body)
+	case "onlyoffice":
+		return c.convertOnlyOffice(ctx, ext, key, name, src)
+	}
+	return nil, fmt.Errorf("office: provider %q cannot convert", c.provider)
+}
+
+// CanConvert sagt, ob dieser Anbieter das Wandeln überhaupt anbietet. Für die
+// Oberfläche: Ohne das gäbe es einen Knopf, der nur Fehler erzeugt.
+func (c *Client) CanConvert() bool {
+	return c != nil && (c.provider == "collabora" || c.provider == "onlyoffice")
+}
+
+// ── Collabora ────────────────────────────────────────────────────────────────
+
+func (c *Client) convertCollabora(ctx context.Context, name string, body io.Reader) ([]byte, error) {
+	var buf bytes.Buffer
+	mw := multipart.NewWriter(&buf)
+	// Der Feldname ist vorgeschrieben („data"), der Dateiname bestimmt, wie
+	// Collabora den Typ erkennt – ohne Endung rät es und liegt daneben.
+	part, err := mw.CreateFormFile("data", name)
+	if err != nil {
+		return nil, fmt.Errorf("build request: %w", err)
+	}
+	if _, err := io.Copy(part, body); err != nil {
+		return nil, fmt.Errorf("read source: %w", err)
+	}
+	if err := mw.Close(); err != nil {
+		return nil, fmt.Errorf("build request: %w", err)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost,
+		c.baseURL+"/cool/convert-to/pdf", &buf)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", mw.FormDataContentType())
+
+	resp, err := c.http.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("convert: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("convert: office server answered %d", resp.StatusCode)
+	}
+	// Collabora antwortet mit dem PDF selbst, nicht mit einer Auskunft.
+	return readPDF(resp.Body)
+}
+
+// ── OnlyOffice / Euro-Office ────────────────────────────────────────────────
+
+type convertResponse struct {
+	FileURL    string `json:"fileUrl"`
+	FileType   string `json:"fileType"`
+	Percent    int    `json:"percent"`
+	EndConvert bool   `json:"endConvert"`
+	// Error ist eine Zahl, keine Meldung: -8 heißt „Signatur fehlt oder ist
+	// falsch", -4 „Quelle nicht erreichbar". Die Zahl steht deshalb im
+	// Fehlertext, sonst sucht man im Log des anderen Servers.
+	Error int `json:"error"`
+}
+
+func (c *Client) convertOnlyOffice(ctx context.Context, ext, key, name, src string) ([]byte, error) {
+	if src == "" {
+		return nil, fmt.Errorf("convert: no source address for the document server")
+	}
+	payload := map[string]any{
+		// Synchron: Die Umwandlung dauert Sekunden, und ein zweiter Aufruf zum
+		// Nachfragen wäre ein Zustand mehr, den jemand verwalten muss.
+		"async":      false,
+		"filetype":   strings.TrimPrefix(ext, "."),
+		"key":        key,
+		"outputtype": "pdf",
+		"title":      name,
+		"url":        src,
+	}
+	if c.jwtSecret != "" {
+		// Die Signatur trägt genau die Nutzlast, die auch gesendet wird –
+		// gemessen: ohne sie antwortet der Server `{"error":-8}`.
+		payload["token"] = signJWT(c.jwtSecret, payload)
+	}
+	raw, err := json.Marshal(payload)
+	if err != nil {
+		return nil, err
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost,
+		c.baseURL+"/ConvertService.ashx", bytes.NewReader(raw))
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	// Ohne diesen Kopf antwortet der Server in XML.
+	req.Header.Set("Accept", "application/json")
+
+	resp, err := c.http.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("convert: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("convert: document server answered %d", resp.StatusCode)
+	}
+	var out convertResponse
+	if err := json.NewDecoder(io.LimitReader(resp.Body, 1<<20)).Decode(&out); err != nil {
+		return nil, fmt.Errorf("convert: unreadable answer: %w", err)
+	}
+	if out.Error != 0 {
+		return nil, fmt.Errorf("convert: document server error %d", out.Error)
+	}
+	if !out.EndConvert || out.FileURL == "" {
+		return nil, fmt.Errorf("convert: document server did not finish (%d%%)", out.Percent)
+	}
+
+	// **Die zurückgegebene Adresse ist nicht vertrauenswürdig.** Sie kommt aus
+	// der Antwort eines anderen Servers, und wir würden sie gleich abrufen –
+	// das ist die Stelle, an der aus einer Umwandlung ein Zugriff auf
+	// 169.254.169.254 würde. Der Wähler des Transports lässt ohnehin nur
+	// Adressen aus OFFICE_ALLOWED_HOSTS zu; hier steht die Prüfung trotzdem
+	// noch einmal ausdrücklich, weil eine klare Meldung mehr wert ist als ein
+	// abgewiesener Verbindungsversuch tief im Netzstapel.
+	if err := c.sameHostAsServer(out.FileURL); err != nil {
+		return nil, err
+	}
+
+	get, err := http.NewRequestWithContext(ctx, http.MethodGet, out.FileURL, nil)
+	if err != nil {
+		return nil, err
+	}
+	res2, err := c.http.Do(get)
+	if err != nil {
+		return nil, fmt.Errorf("fetch result: %w", err)
+	}
+	defer res2.Body.Close()
+	if res2.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("fetch result: answered %d", res2.StatusCode)
+	}
+	return readPDF(res2.Body)
+}
+
+// sameHostAsServer prüft, dass eine Adresse auf denselben Rechner zeigt wie
+// der Office-Server selbst.
+func (c *Client) sameHostAsServer(raw string) error {
+	u, err := url.Parse(raw)
+	if err != nil {
+		return fmt.Errorf("convert: unreadable result address")
+	}
+	base, err := url.Parse(c.baseURL)
+	if err != nil {
+		return fmt.Errorf("convert: OFFICE_URL is not a valid address")
+	}
+	if !strings.EqualFold(u.Hostname(), base.Hostname()) {
+		return fmt.Errorf("convert: result address points elsewhere (%q), refused", u.Hostname())
+	}
+	return nil
+}
+
+// ── gemeinsam ────────────────────────────────────────────────────────────────
+
+// maxPDFBytes begrenzt, was als Ergebnis angenommen wird. Ohne Grenze
+// bestimmte der andere Server, wie viel Speicher wir belegen.
+const maxPDFBytes = 256 << 20
+
+func readPDF(r io.Reader) ([]byte, error) {
+	data, err := io.ReadAll(io.LimitReader(r, maxPDFBytes+1))
+	if err != nil {
+		return nil, fmt.Errorf("read result: %w", err)
+	}
+	if len(data) > maxPDFBytes {
+		return nil, fmt.Errorf("read result: converted file is too large")
+	}
+	// Kein Vertrauen auf den Content-Type: Collabora liefert
+	// `application/octet-stream`. Die ersten Bytes sind die Auskunft, die
+	// zählt – und sie verhindert, dass eine Fehlerseite als PDF abgelegt wird.
+	if !bytes.HasPrefix(data, []byte("%PDF-")) {
+		return nil, fmt.Errorf("read result: answer is not a PDF")
+	}
+	return data, nil
+}
+
+// signJWT baut ein HS256-Token über die Nutzlast.
+//
+// Von Hand statt mit einer Bibliothek: Es sind zwölf Zeilen, und die einzige
+// Alternative wäre eine weitere Abhängigkeit für einen einzigen Aufruf.
+func signJWT(secret string, payload map[string]any) string {
+	claims := make(map[string]any, len(payload)+1)
+	for k, v := range payload {
+		claims[k] = v
+	}
+	claims["exp"] = time.Now().Add(jwtLifetime).Unix()
+
+	enc := func(v any) string {
+		b, _ := json.Marshal(v)
+		return base64.RawURLEncoding.EncodeToString(b)
+	}
+	head := enc(map[string]string{"alg": "HS256", "typ": "JWT"})
+	body := enc(claims)
+	mac := hmac.New(sha256.New, []byte(secret))
+	mac.Write([]byte(head + "." + body))
+	return head + "." + body + "." +
+		base64.RawURLEncoding.EncodeToString(mac.Sum(nil))
+}

backend/internal/office/convert_test.go

@@ -0,0 +1,122 @@
+package office
+
+import (
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/json"
+	"strings"
+	"testing"
+)
+
+// Die drei Stellen, an denen ein Fehler **still** wäre: eine Signatur, die
+// nicht stimmt (der Server sagt nur „-8"), eine Fehlerseite, die als PDF
+// abgelegt wird, und eine Ergebnisadresse, die woanders hinzeigt.
+
+func TestSignJWTIsVerifiable(t *testing.T) {
+	const secret = "geheimnis-mit-mindestens-32-zeichen!!"
+	token := signJWT(secret, map[string]any{"outputtype": "pdf", "key": "abc"})
+
+	parts := strings.Split(token, ".")
+	if len(parts) != 3 {
+		t.Fatalf("Token hat %d Teile, erwartet 3", len(parts))
+	}
+
+	mac := hmac.New(sha256.New, []byte(secret))
+	mac.Write([]byte(parts[0] + "." + parts[1]))
+	want := base64.RawURLEncoding.EncodeToString(mac.Sum(nil))
+	if parts[2] != want {
+		t.Errorf("Signatur stimmt nicht:\n  ist:  %s\n  soll: %s", parts[2], want)
+	}
+
+	head, err := base64.RawURLEncoding.DecodeString(parts[0])
+	if err != nil {
+		t.Fatalf("Kopf nicht dekodierbar: %v", err)
+	}
+	var h map[string]string
+	if err := json.Unmarshal(head, &h); err != nil {
+		t.Fatalf("Kopf ist kein JSON: %v", err)
+	}
+	if h["alg"] != "HS256" {
+		t.Errorf("alg = %q, erwartet HS256", h["alg"])
+	}
+
+	body, _ := base64.RawURLEncoding.DecodeString(parts[1])
+	var claims map[string]any
+	if err := json.Unmarshal(body, &claims); err != nil {
+		t.Fatalf("Nutzlast ist kein JSON: %v", err)
+	}
+	if claims["key"] != "abc" || claims["outputtype"] != "pdf" {
+		t.Errorf("Nutzlast fehlt oder ist verändert: %v", claims)
+	}
+	// Ohne Ablauf gälte ein abgefangenes Token für immer.
+	if _, ok := claims["exp"]; !ok {
+		t.Error("exp fehlt – das Token liefe nie ab")
+	}
+	// Die eigene Signatur darf nicht Teil der signierten Nutzlast sein.
+	if _, ok := claims["token"]; ok {
+		t.Error("die Signatur signiert sich selbst mit")
+	}
+}
+
+func TestReadPDFRejectsNonPDF(t *testing.T) {
+	cases := map[string]string{
+		"Fehlerseite":  "<html><body>500 Internal Server Error</body></html>",
+		"leer":         "",
+		"JSON-Fehler":  `{"error":-4}`,
+		"fast ein PDF": "%PD",
+	}
+	for name, body := range cases {
+		if _, err := readPDF(strings.NewReader(body)); err == nil {
+			t.Errorf("%s wurde als PDF angenommen", name)
+		}
+	}
+	// Ein echtes PDF muss durchkommen – sonst prüft der Test nichts.
+	if _, err := readPDF(strings.NewReader("%PDF-1.7\nInhalt")); err != nil {
+		t.Errorf("echtes PDF abgelehnt: %v", err)
+	}
+}
+
+func TestSameHostAsServerRefusesForeignAddresses(t *testing.T) {
+	c := &Client{baseURL: "http://office:80"}
+
+	// Die Ergebnisadresse kommt aus der Antwort eines anderen Servers. Genau
+	// hier würde aus einer Umwandlung ein Zugriff auf einen fremden Dienst.
+	foreign := []string{
+		"http://169.254.169.254/latest/meta-data/",
+		"http://localhost:8080/api/v1/admin/users",
+		"http://office.evil.example.com/x.pdf",
+		"file:///etc/passwd",
+		"://kaputt",
+	}
+	for _, raw := range foreign {
+		if err := c.sameHostAsServer(raw); err == nil {
+			t.Errorf("fremde Adresse angenommen: %s", raw)
+		}
+	}
+
+	for _, ok := range []string{
+		"http://office/cache/files/x.pdf",
+		"http://office:80/cache/files/x.pdf",
+		"http://OFFICE/cache/files/x.pdf", // Groß-/Kleinschreibung zählt nicht
+	} {
+		if err := c.sameHostAsServer(ok); err != nil {
+			t.Errorf("eigene Adresse abgelehnt: %s (%v)", ok, err)
+		}
+	}
+}
+
+func TestSanitizeFilename(t *testing.T) {
+	cases := map[string]string{
+		`Rechnung "2026".docx`: "Rechnung 2026",
+		// Zeilenumbrüche raus – sie könnten eine zweite Kopfzeile erfinden.
+		"kaputt\r\nInjected: x.odt": "kaputtInjected: x",
+		".odt":                      ".odt",
+		"":                          "document",
+	}
+	for in, want := range cases {
+		if got := sanitizeFilename(in); got != want {
+			t.Errorf("sanitizeFilename(%q) = %q, erwartet %q", in, got, want)
+		}
+	}
+}

backend/internal/office/discovery.go

@@ -48,6 +48,9 @@ type Client struct {
 	// selbst sieht – im Compose-Netz also `collabora:9980`. Die schickt man
 	// keinem Browser.
 	publicBase string
+	// jwtSecret signiert Aufrufe an die **eigene** API von OnlyOffice (die
+	// Umwandlung). Der WOPI-Weg braucht ihn nicht, der hat eigene Token.
+	jwtSecret string
 	http      *http.Client
 
 	mu      sync.Mutex
@@ -62,7 +65,7 @@ type Client struct {
 // auf – ohne Grenze wird daraus ein Weg ins interne Netz, sobald jemand die
 // Konfiguration beeinflussen kann (SSRF). Die Adresse aus OFFICE_URL zählt
 // immer dazu, sonst wäre die Voreinstellung unbrauchbar.
-func NewClient(provider, baseURL, publicURL string, allowedHosts []string, insecureTLS bool) (*Client, error) {
+func NewClient(provider, baseURL, publicURL string, allowedHosts []string, insecureTLS bool, jwtSecret string) (*Client, error) {
 	u, err := url.Parse(baseURL)
 	if err != nil || u.Host == "" {
 		return nil, fmt.Errorf("OFFICE_URL is not a valid address: %q", baseURL)
@@ -96,6 +99,7 @@ func NewClient(provider, baseURL, publicURL string, allowedHosts []string, insec
 		provider:   provider,
 		baseURL:    strings.TrimRight(baseURL, "/"),
 		publicBase: strings.TrimRight(publicURL, "/"),
+		jwtSecret:  jwtSecret,
 		http:       &http.Client{Timeout: 20 * time.Second, Transport: transport},
 	}, nil
 }

backend/internal/office/preview.go

@@ -0,0 +1,229 @@
+package office
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"sync"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/google/uuid"
+	"github.com/rs/zerolog/log"
+
+	"aether/internal/auth"
+	"aether/internal/files"
+	"aether/pkg/response"
+)
+
+// Ein Office-Dokument als PDF ansehen, ohne den Editor.
+//
+// Am Telefon ist das der Normalfall: nachsehen, nicht schreiben. Der Editor
+// bleibt einen Knopfdruck entfernt.
+//
+// ── Warum es je Datei nur **ein** PDF gibt ──────────────────────────────────
+//
+// Der Schlüssel ist `previews/<datei-id>.pdf` und trägt die Fassungsnummer
+// **nicht** im Namen. Eine neue Fassung überschreibt das alte PDF, statt ein
+// zweites danebenzulegen – häufen kann sich hier also nichts, das ist keine
+// Frage des Aufräumens, sondern des Schlüssels.
+//
+// Ob das abgelegte PDF noch zum Inhalt passt, sagt `files.preview_version`.
+// Steht dort eine andere Zahl als die aktuelle Fassung, wird neu gewandelt und
+// überschrieben. Das ist derselbe Gedanke wie beim Vorschaubild, nur dass
+// dieses beim Hochladen entsteht und das PDF erst, wenn es jemand ansieht.
+//
+// ── Was das für die Platte heißt ────────────────────────────────────────────
+//
+// Ein PDF entsteht nur für Dokumente, die wirklich jemand angesehen hat, und
+// es zählt nicht gegen das Kontingent: Es ist abgeleitet, niemand hat es
+// hochgeladen. Beim endgültigen Löschen verschwindet es mit, und der GC kennt
+// den Ordner – beides ist nötig, und beides einzeln geprüft.
+
+// previewKey ist der Ablageort. Öffentlich, weil Papierkorb und GC ihn
+// ebenfalls kennen müssen.
+func PreviewKey(fileID string) string { return "previews/" + fileID + ".pdf" }
+
+// PreviewPrefix ist der Ordner, den der GC durchgeht.
+const PreviewPrefix = "previews"
+
+// maxPreviewSource: Größere Dateien werden nicht gewandelt.
+//
+// Nicht aus Sparsamkeit: Ein Dokument dieser Größe beschäftigt den
+// Office-Server minutenlang, und das auf einen Fingertipp hin. Wer so etwas
+// ansehen will, bekommt den Editor angeboten – dort lädt es Stück für Stück.
+const maxPreviewSource = 100 << 20
+
+// Ein Riegel je Datei: Tippt jemand zweimal, wandelt der Server nicht zweimal.
+//
+// Ohne das ist es kein Fehler, nur Verschwendung – beide Läufe schreiben
+// denselben Inhalt, und geschrieben wird atomar. Der Riegel spart die zweite
+// Umwandlung, nicht die Richtigkeit.
+var previewLocks sync.Map // fileID -> *sync.Mutex
+
+func lockPreview(id string) func() {
+	m, _ := previewLocks.LoadOrStore(id, &sync.Mutex{})
+	mu := m.(*sync.Mutex)
+	mu.Lock()
+	return mu.Unlock
+}
+
+// GET /api/v1/files/{id}/preview.pdf
+func (h *Handler) PreviewPDF(w http.ResponseWriter, r *http.Request) {
+	if !h.Enabled() || !h.client.CanConvert() {
+		response.Error(w, http.StatusNotImplemented, "this server cannot convert documents")
+		return
+	}
+	f, userID, ok := h.resolveSession(w, r)
+	if !ok {
+		return
+	}
+	if !Editable(f.Name) {
+		response.Error(w, http.StatusUnsupportedMediaType, "this file type has no office preview")
+		return
+	}
+	if f.Size > maxPreviewSource {
+		// 413 und nicht 500: Die Oberfläche unterscheidet daran, ob sie den
+		// Editor anbieten soll oder einen Fehler zeigt.
+		response.Error(w, http.StatusRequestEntityTooLarge,
+			"this document is too large to be shown as a PDF")
+		return
+	}
+
+	unlock := lockPreview(f.ID.String())
+	defer unlock()
+
+	key := PreviewKey(f.ID.String())
+	have, err := h.files.PreviewVersion(r.Context(), f.ID)
+	if err != nil && !errors.Is(err, files.ErrNotFound) {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+
+	if have == f.Version {
+		if rc, err := h.blobs.Get(r.Context(), key); err == nil {
+			defer rc.Close()
+			servePDF(w, f.Name, f.Version)
+			_, _ = io.Copy(w, rc)
+			return
+		}
+		// Vermerk vorhanden, Datei weg – etwa, weil der GC sie geholt hat oder
+		// jemand im Datenordner aufgeräumt hat. Kein Fehler, nur ein Grund,
+		// sie neu zu erzeugen.
+		log.Ctx(r.Context()).Info().Str("file_id", f.ID.String()).
+			Msg("office preview: vermerkt, aber nicht auf der Platte – wird neu gewandelt")
+	}
+
+	pdf, err := h.convert(r.Context(), f, userID)
+	if err != nil {
+		log.Ctx(r.Context()).Warn().Err(err).Str("file_id", f.ID.String()).
+			Msg("office preview: Umwandlung fehlgeschlagen")
+		response.Error(w, http.StatusBadGateway, "the document could not be converted")
+		return
+	}
+
+	// Erst der Blob, dann der Vermerk. Andersherum zeigte die Datenbank auf
+	// etwas, das es noch nicht gibt – und der nächste Abruf lieferte nichts,
+	// ohne es zu merken.
+	if _, _, err := h.blobs.Put(r.Context(), key, bytes.NewReader(pdf)); err != nil {
+		log.Ctx(r.Context()).Warn().Err(err).Msg("office preview: konnte nicht abgelegt werden")
+	} else if err := h.files.SetPreviewVersion(r.Context(), f.ID, f.Version); err != nil {
+		log.Ctx(r.Context()).Warn().Err(err).Msg("office preview: Vermerk fehlgeschlagen")
+	}
+
+	servePDF(w, f.Name, f.Version)
+	_, _ = w.Write(pdf)
+}
+
+// convert holt das PDF beim Office-Server – auf dem Weg, den der Anbieter
+// versteht.
+func (h *Handler) convert(ctx context.Context, f *files.File, userID uuid.UUID) ([]byte, error) {
+	ext := Extension(f.Name)
+	// Der Schlüssel muss sich mit dem Inhalt ändern: OnlyOffice speichert
+	// selbst danach zwischen und lieferte sonst nach einer Bearbeitung das
+	// alte Dokument aus.
+	key := fmt.Sprintf("%s-%d", f.ID.String(), f.Version)
+
+	switch h.client.Provider() {
+	case "collabora":
+		// Collabora bekommt die Bytes. Der Umweg über eine Adresse wäre hier
+		// keiner: Es müsste sie abrufen, also bräuchte es dieselbe
+		// Erreichbarkeit – und ein Token mehr in der Welt.
+		rc, err := h.blobs.Get(ctx, f.StorageKey)
+		if err != nil {
+			return nil, fmt.Errorf("read source: %w", err)
+		}
+		defer rc.Close()
+		return h.client.ConvertToPDF(ctx, ext, key, f.Name, "", rc)
+
+	default:
+		// OnlyOffice holt die Datei selbst – über denselben WOPI-Weg, den es
+		// zum Bearbeiten ohnehin geht. Das Token gilt kurz und nur für diese
+		// Datei; ein zweiter, offener Abholpunkt entsteht dadurch nicht.
+		token, _ := h.signer.Issue(f.ID, userID, false)
+		src := fmt.Sprintf("%s/wopi/files/%s/contents?access_token=%s",
+			h.wopiURL, f.ID, token)
+		return h.client.ConvertToPDF(ctx, ext, key, f.Name, src, nil)
+	}
+}
+
+func servePDF(w http.ResponseWriter, name string, version int) {
+	w.Header().Set("Content-Type", "application/pdf")
+	w.Header().Set("X-Content-Type-Options", "nosniff")
+	// Anzeigen, nicht herunterladen – und unter dem Namen des Dokuments.
+	w.Header().Set("Content-Disposition",
+		fmt.Sprintf(`inline; filename="%s.pdf"`, sanitizeFilename(name)))
+	// Privat: Das PDF trägt denselben Inhalt wie das Dokument und gehört in
+	// keinen gemeinsamen Zwischenspeicher. Die Fassung steht in der Adresse,
+	// der Browser holt es nach einer Änderung also von selbst neu.
+	w.Header().Set("Cache-Control", "private, max-age=3600")
+	w.Header().Set("X-Document-Version", fmt.Sprintf("%d", version))
+}
+
+// sanitizeFilename nimmt einem Dateinamen alles, was in einer Kopfzeile
+// gefährlich wäre – Anführungszeichen und Zeilenumbrüche.
+func sanitizeFilename(name string) string {
+	name = strings.NewReplacer(`"`, "", "\r", "", "\n", "", ";", "").Replace(name)
+	if i := strings.LastIndexByte(name, '.'); i > 0 {
+		name = name[:i]
+	}
+	if name == "" {
+		name = "document"
+	}
+	return name
+}
+
+// resolveSession löst eine Anfrage **aus dem Browser** auf – mit Sitzung, im
+// Gegensatz zu `authorize`, das den WOPI-Weg des Office-Servers bedient.
+//
+// Getrennt gehalten, weil die beiden Wege verschiedene Berechtigungen haben
+// und das nie durcheinandergeraten darf: Hier zählt die Anmeldung, dort ein
+// Token für genau eine Datei.
+func (h *Handler) resolveSession(w http.ResponseWriter, r *http.Request) (*files.File, uuid.UUID, bool) {
+	id, err := uuid.Parse(chi.URLParam(r, "id"))
+	if err != nil {
+		response.Error(w, http.StatusNotFound, "not found")
+		return nil, uuid.Nil, false
+	}
+	user := auth.UserFromContext(r.Context())
+	if user == nil {
+		response.Error(w, http.StatusUnauthorized, "not signed in")
+		return nil, uuid.Nil, false
+	}
+	// 404 auch bei fehlendem Zugriff: Ein „verboten" verriete, dass es die
+	// Datei gibt.
+	access, err := h.acl.ResolveFile(r.Context(), user.ID, id)
+	if err != nil {
+		response.Error(w, http.StatusNotFound, "not found")
+		return nil, uuid.Nil, false
+	}
+	f, err := h.files.GetFile(r.Context(), id, access.OwnerID)
+	if err != nil {
+		response.Error(w, http.StatusNotFound, "not found")
+		return nil, uuid.Nil, false
+	}
+	return f, user.ID, true
+}

backend/pkg/config/config.go

@@ -113,6 +113,11 @@ type Config struct {
 	// OfficeInsecureTLS erlaubt ein selbstsigniertes Zertifikat am
 	// Office-Server. Nur für den Testaufbau auf demselben Rechner.
 	OfficeInsecureTLS bool
+	// OfficeJWTSecret signiert Aufrufe an die eigene API von OnlyOffice und
+	// Euro-Office – gebraucht wird das für die Umwandlung nach PDF. Collabora
+	// kennt es nicht. Fehlt es, während der Server `JWT_ENABLED` hat,
+	// antwortet er auf jede Umwandlung mit `{"error":-8}`.
+	OfficeJWTSecret string
 }
 
 // splitList zerlegt eine kommagetrennte Liste und wirft Leeres weg.
@@ -199,6 +204,7 @@ func Load() (*Config, error) {
 
 		OfficeProvider:     strings.ToLower(strings.TrimSpace(getEnv("OFFICE_PROVIDER", ""))),
 		OfficeURL:          strings.TrimRight(getEnv("OFFICE_URL", ""), "/"),
+		OfficeJWTSecret:    getEnv("OFFICE_JWT_SECRET", ""),
 		OfficePublicURL:    strings.TrimRight(getEnv("OFFICE_PUBLIC_URL", ""), "/"),
 		HoneybarOrigin:     strings.TrimRight(getEnv("HONEYBAR_ORIGIN", ""), "/"),
 		HoneybarKey:        getEnv("HONEYBAR_KEY", ""),

backend/pkg/db/migrations/000020_office_preview.down.sql

@@ -0,0 +1 @@
+ALTER TABLE files DROP COLUMN IF EXISTS preview_version;

backend/pkg/db/migrations/000020_office_preview.up.sql

@@ -0,0 +1,9 @@
+-- Die Fassung, aus der das zwischengespeicherte PDF entstanden ist.
+--
+-- Der Blob heißt `previews/<datei-id>.pdf` – **ohne** Fassungsnummer im
+-- Namen. Damit kann es je Datei nie mehr als eine Vorschau geben: Eine neue
+-- Fassung überschreibt die alte, statt eine zweite danebenzulegen. Ob die
+-- vorhandene noch zum Inhalt passt, sagt diese Spalte.
+--
+-- 0 heißt "keine". Dateifassungen zählen ab 1.
+ALTER TABLE files ADD COLUMN IF NOT EXISTS preview_version INT NOT NULL DEFAULT 0;

cloud-projekt-plan.md

@@ -273,6 +273,15 @@ Geplante Ideen (noch nicht umgesetzt):
 - Glasmorphismus-Theme (transluzente Sidebar/Cards mit Blur-Effekt)
 - Logo und App-Symbol bereits in Phase 4.5/D umgesetzt
 
+- ✅ **Office-Dokumente am Telefon als PDF ansehen** (`internal/office/convert.go` + `preview.go`, Migration 000020, 31.08.2026, Wunsch von Marc). Am Finger öffnet ein `.docx` nicht mehr den Editor, sondern das gewandelte PDF im eigenen Betrachter; „Edit" daneben führt trotzdem hinein. Am Schreibtisch bleibt alles wie es war.
+  - **Warum überhaupt:** Der Web-Editor ist eine vollständige Textverarbeitung. Menüband, Formatleisten und Eigenschaftenbereich sind nicht Beiwerk, sondern das Produkt – auf 400 Pixeln bleibt für das Dokument ein Rechteck. Marc hat Collabora **und** OnlyOffice ausprobiert, mit demselben Ergebnis; das ist der Grund, aus dem hier kein besserer Bedienmodus gesucht wurde, sondern ein anderes Werkzeug. Nextcloud löst es in seiner App genauso: ansehen statt bearbeiten.
+  - **Gewandelt wird von dem Server, der auch bearbeitet.** Wer OnlyOffice wegen der Treue zu MS-Office-Formaten nimmt, aber Collabora das PDF rechnen ließe, sähe unterwegs ein LibreOffice-Layout desselben Dokuments – zwei Geräte, zwei Umbrüche, ausgerechnet bei Unterlagen. Beide Wege sind deshalb gebaut: Collabora nimmt die Bytes (`/cool/convert-to/pdf`), OnlyOffice eine Adresse, holt die Datei selbst und antwortet mit einer Adresse (`/ConvertService.ashx`, HS256-signiert).
+  - **Je Datei gibt es genau ein PDF, und das ist keine Frage des Aufräumens, sondern des Schlüssels:** `previews/<id>.pdf` trägt die Fassung **nicht** im Namen. Eine neue Fassung überschreibt, statt danebenzulegen. Ob das Abgelegte noch passt, sagt `files.preview_version`. Gemessen: Nach dem erneuten Hochladen stand die Datei auf Fassung 2, `preview_version` auf 2, und im Ordner lag weiterhin genau eine Datei.
+  - **Der GC kennt den Ordner – und die Referenz.** Beides musste sein: ohne Präfix wächst er ewig, ohne Referenz löscht der GC das PDF nach einem Tag weg. Genau dieser zweite Fehler ist beim Logo und beim Favicon schon einmal passiert. Beide Richtungen einzeln geprüft (herrenloses PDF von vorgestern → weg; echtes → bleibt).
+  - **Die zurückgegebene Adresse ist nicht vertrauenswürdig.** OnlyOffice antwortet nicht mit dem PDF, sondern mit einer Adresse, die wir gleich abrufen – das ist die Stelle, an der aus einer Umwandlung ein Zugriff auf `169.254.169.254` würde. Der Wähler des Transports lässt ohnehin nur `OFFICE_ALLOWED_HOSTS` zu; die ausdrückliche Prüfung steht zusätzlich da und ist mit Test abgedeckt.
+  - **Zählt gegen kein Kontingent** (Entscheidung von Marc): Es ist abgeleitet, niemand hat es hochgeladen. Platte kostet es trotzdem – deshalb steht der Platzbedarf jetzt im Admin-Bereich neben der Bereinigung, zusammen mit Vorschau- und Profilbildern. Ein Ordner, der wächst, ohne dass ihn irgendwo jemand sieht, ist eine stille Überraschung.
+  - Gemessen an dieser Anlage: erster Abruf 1,05 s, zweiter 0,009 s. Fremde Kennung `404`, ohne Anmeldung `401`, Nicht-Office-Datei `415`, zu große Datei `413` (die Oberfläche bietet daraufhin den Editor an).
+
 - ⏸️ **Im Papierkorb ansehen, was es war – vertagt** (26.08.2026, Wunsch von Marc: „erstmal noch nicht wichtig"). Die kleinen Vorschaubilder sind seit dem 26.08. wieder da (`GetThumbnail` sah nur in nicht-gelöschten Dateien nach). Gemeint ist der Schritt danach: eine Datei im Papierkorb **öffnen** und ansehen, bevor man „Delete forever" drückt.
   - **Warum es überhaupt eine Idee ist:** Der Papierkorb ist die einzige Ansicht ohne Vorschau – ausgerechnet die, in der die Entscheidung unwiderruflich ist. Wer nach zwei Wochen aufräumt, sieht einen Namen wie `IMG_2481.jpg` und rät.
   - **Wo es hängt:** an derselben Stelle wie eben das Vorschaubild. `Download` schlägt die Datei mit `is_deleted = false` nach (`handler.go:411`), der Vorschau-Dialog hängt außerdem an der Dateiliste, nicht an einem einzelnen Eintrag – er blättert zum nächsten Bild und kennt Umbenennen, Teilen, Löschen. Im Papierkorb wäre davon fast nichts sinnvoll.

deploy/.env.example

@@ -108,7 +108,10 @@ OFFICE_PUBLIC_URL=
 OFFICE_WOPI_URL=
 # Gegen SSRF; der Host aus OFFICE_URL zählt immer dazu.
 OFFICE_ALLOWED_HOSTS=
-# Nur OnlyOffice/Euro-Office, mind. 32 Zeichen.
+# Nur OnlyOffice/Euro-Office, mind. 32 Zeichen. Muss mit JWT_SECRET des
+# Office-Containers übereinstimmen: Ohne ihn schlägt das Wandeln nach PDF fehl
+# (der Server antwortet `{"error":-8}`). Für den WOPI-Weg wird er nicht
+# gebraucht, der hat eigene Token.
 OFFICE_JWT_SECRET=
 OFFICE_INSECURE_TLS=false       # nur für Tests mit selbstsigniertem Zertifikat
 

frontend/src/api/client.ts

@@ -601,6 +601,17 @@ export const filesApi = {
    * Gemessen: dreimal dieselbe Datei hochgeladen ergibt dreimal dieselbe ID
    * mit den Fassungen 1, 2, 3.
    */
+  /**
+   * Ein Office-Dokument als PDF – zum Ansehen, ohne den Editor.
+   *
+   * Die Fassung steht in der Adresse: Nach einer Bearbeitung ändert sie sich,
+   * und der Browser holt das PDF von selbst neu, statt ein Dokument von
+   * gestern aus seinem Zwischenspeicher zu zeigen. Derselbe Kniff wie beim
+   * Vorschaubild.
+   */
+  officePreview: (id: string, version?: number) =>
+    `/api/v1/files/${id}/preview.pdf${version ? `?v=${version}` : ''}`,
+
   thumbnail: (id: string, version?: number | string) =>
     `/api/v1/files/${id}/thumbnail${version ? `?v=${encodeURIComponent(version)}` : ''}`,
 
@@ -838,6 +849,10 @@ export const adminApi = {
     return request<{ entries: AuditEntry[]; total: number }>('GET', `/admin/audit${suffix}`)
   },
   listAuditActions: () => request<string[]>('GET', '/admin/audit/actions'),
+  /** Platzbedarf der abgeleiteten Daten – zählt gegen kein Kontingent. */
+  derivedStorage: () =>
+    request<{ prefix: string; files: number; bytes: number }[]>('GET', '/admin/storage/derived'),
+
   runCleanup: () => request<{
     scanned: number; orphans: number; deleted: number
     freed_bytes: number; skipped_young: number

frontend/src/components/FilePreview.tsx

@@ -19,6 +19,17 @@ interface Props {
   onClose: () => void
   /** Nach dem Speichern: Liste neu holen, damit Größe und Datum stimmen. */
   onSaved?: () => void
+  /**
+   * Ein Office-Dokument als PDF zeigen statt im Editor.
+   *
+   * Am Telefon der Normalfall: Der Editor ist dort eine vollständige
+   * Textverarbeitung, und vom Dokument bleibt zwischen seinen Leisten ein
+   * Rechteck übrig. Zum Nachsehen – und das ist unterwegs fast immer der
+   * Anlass – ist ein PDF im eigenen Betrachter das bessere Werkzeug.
+   */
+  asOfficePdf?: boolean
+  /** „Trotzdem bearbeiten" – nur gesetzt, wenn es einen Editor gibt. */
+  onEdit?: () => void
   /**
    * Suchwort, mit dem die Datei gefunden wurde. Der PDF-Betrachter springt
    * damit zur Fundstelle, statt auf Seite 1 zu beginnen – der Grund, aus dem
@@ -90,10 +101,12 @@ export function canPreview(file: FileItem): boolean {
   return kindOf(file.mime_type, file.name) !== 'none'
 }
 
-export default function FilePreview({ file, onPrev, onNext, onClose, onSaved, searchTerm }: Props) {
-  const kind = kindOf(file.mime_type, file.name)
+export default function FilePreview({ file, onPrev, onNext, onClose, onSaved, searchTerm, asOfficePdf, onEdit }: Props) {
+  // Ein Office-Dokument ist für den Browser sonst „nichts anzeigbares" – als
+  // gewandeltes PDF ist es eins.
+  const kind = asOfficePdf ? 'pdf' : kindOf(file.mime_type, file.name)
   const narrow = useNarrow()
-  const src = filesApi.inline(file.id)
+  const src = asOfficePdf ? filesApi.officePreview(file.id, file.version) : filesApi.inline(file.id)
   const [text, setText] = useState<string | null>(null)
   const [tooBig, setTooBig] = useState(false)
   const [editing, setEditing] = useState(false)
@@ -205,6 +218,23 @@ export default function FilePreview({ file, onPrev, onNext, onClose, onSaved, se
           {file.name}
         </span>
 
+        {/* Der Weg in den Editor bleibt offen – eine Ansicht ohne Ausweg wäre
+            eine Bevormundung. Er steht bewusst *neben* dem Namen und nicht
+            als Hauptknopf: Am Telefon ist Nachsehen der Anlass, Bearbeiten
+            die Ausnahme. */}
+        {asOfficePdf && onEdit && (
+          <button
+            onClick={onEdit}
+            style={{
+              padding: '6px 12px', borderRadius: 8, fontSize: 12, flexShrink: 0,
+              border: '1px solid var(--color-border)', background: 'transparent',
+              color: 'var(--color-text)', cursor: 'pointer', whiteSpace: 'nowrap',
+            }}
+          >
+            Edit
+          </button>
+        )}
+
         {kind === 'text' && !tooBig && text !== null && (
           editing ? (
             <>

frontend/src/components/FileViews.tsx

@@ -34,7 +34,7 @@ function FolderIcon({ size = 24, group = false }: { size?: number; group?: boole
  * nicht zweimal auf denselben Pixel tippt. Der Doppelklick ist eine
  * Mausgeste; am Finger ist er nie angekommen.
  */
-function useCoarsePointer(): boolean {
+export function useCoarsePointer(): boolean {
   const [coarse, setCoarse] = useState(
     () => typeof matchMedia === 'function' && matchMedia('(pointer: coarse)').matches,
   )

frontend/src/pages/FileBrowser.tsx

@@ -7,7 +7,7 @@ import {
 import Breadcrumb from '../components/Breadcrumb'
 import SearchBox from '../components/SearchBox'
 import PageHeader from '../components/PageHeader'
-import GridView, { ListView } from '../components/FileViews'
+import GridView, { ListView, useCoarsePointer } from '../components/FileViews'
 import FilePreview, { canPreview } from '../components/FilePreview'
 import ContextMenu, { type MenuItem } from '../components/ContextMenu'
 import UploadQueue, { type UploadItem } from '../components/UploadQueue'
@@ -149,9 +149,14 @@ export default function FileBrowser({
   const [viewMode, setViewMode] = useState<ViewMode>(() => loadPref('aether:view', 'grid'))
   const [sort, setSort] = useState<Sort>(() => loadPref('aether:sort', 'name-asc'))
   const [preview, setPreview] = useState<FileItem | null>(null)
+  /** Office-Dokument als PDF – am Telefon der übliche Weg hinein. */
+  const [officePreview, setOfficePreview] = useState<FileItem | null>(null)
   /** Datei, die gerade im Office-Server bearbeitet wird. */
   const [editing, setEditing] = useState<FileItem | null>(null)
   const { officeEnabled } = useAppSettings()
+  /** Finger oder Maus? Entscheidet, ob ein Office-Dokument als PDF oder im
+   *  Editor aufgeht. */
+  const touchDevice = useCoarsePointer()
 
   /** Datei, zu der gerade aus der Suche gesprungen wurde – siehe openHitFile.
    *  Die Markierung verschwindet von selbst; ein Rahmen, der bleibt, sähe
@@ -310,8 +315,20 @@ export default function FileBrowser({
    * ansieht; heruntergeladen wird, was der Browser nicht zeigen kann.
    */
   function openFile(file: FileItem) {
-    if (officeEnabled && isOfficeFile(file.name)) setEditing(file)
-    else if (canPreview(file)) setPreview(file)
+    if (officeEnabled && isOfficeFile(file.name)) {
+      // Am Telefon zuerst ansehen, nicht bearbeiten. Der Editor ist dort eine
+      // vollständige Textverarbeitung; zwischen Menüband, Formatleisten und
+      // Eigenschaftenbereich bleibt vom Dokument ein Rechteck. Gilt für
+      // Collabora wie für OnlyOffice – beide ausprobiert, dasselbe Bild.
+      //
+      // Die Entscheidung fällt am **Zeigegerät**, nicht an der Fensterbreite:
+      // Ein schmales Fenster auf dem Schreibtisch ist immer noch eine Maus
+      // und eine Tastatur, und dort will man bearbeiten.
+      if (touchDevice) setOfficePreview(file)
+      else setEditing(file)
+      return
+    }
+    if (canPreview(file)) setPreview(file)
     else downloadFile(file)
   }
 
@@ -984,6 +1001,15 @@ export default function FileBrowser({
         />
       )}
 
+      {officePreview && (
+        <FilePreview
+          file={officePreview}
+          asOfficePdf
+          onEdit={() => { const f = officePreview; setOfficePreview(null); setEditing(f) }}
+          onClose={() => setOfficePreview(null)}
+        />
+      )}
+
       {preview && (
         <FilePreview
           file={preview}

frontend/src/pages/admin/AuditTab.tsx

@@ -147,6 +147,14 @@ function IndexingStatus() {
 function StorageCleanup() {
   const [running, setRunning] = useState(false)
   const [result, setResult] = useState<string | null>(null)
+  /** Was Vorschaubilder, Profilbilder und gewandelte Dokumente belegen.
+   *  Steht hier, weil es sonst nirgends steht: Diese Dateien zählen gegen kein
+   *  Kontingent, ihr Ordner könnte also unbemerkt wachsen. */
+  const [derived, setDerived] = useState<{ prefix: string; files: number; bytes: number }[]>([])
+
+  useEffect(() => {
+    adminApi.derivedStorage().then(setDerived).catch(() => {})
+  }, [])
 
   async function run() {
     setRunning(true)
@@ -166,6 +174,8 @@ function StorageCleanup() {
   }
 
   return (
+    <>
+    <DerivedStorage items={derived} />
     <div style={{
       display: 'flex', alignItems: 'center', gap: 12, marginBottom: 16,
       padding: '12px 14px', borderRadius: 10,
@@ -192,6 +202,44 @@ function StorageCleanup() {
         {running ? 'Running…' : 'Run now'}
       </button>
     </div>
+    </>
+  )
+}
+
+/** Namen, die etwas sagen – „thumbs" steht nirgends auf der Oberfläche. */
+const derivedLabels: Record<string, string> = {
+  thumbs: 'Thumbnails',
+  previews: 'Office documents as PDF',
+  avatars: 'Profile pictures',
+}
+
+function DerivedStorage({ items }: { items: { prefix: string; files: number; bytes: number }[] }) {
+  const total = items.reduce((n, i) => n + i.bytes, 0)
+  if (items.length === 0) return null
+  return (
+    <div style={{
+      marginBottom: 16, padding: '12px 14px', borderRadius: 10,
+      border: '1px solid var(--color-border)', background: 'var(--color-surface-2)',
+    }}>
+      <div style={{ fontSize: 13, fontWeight: 600, color: 'var(--color-text)' }}>
+        Generated files — {formatBytes(total)}
+      </div>
+      <div style={{ fontSize: 11, color: 'var(--color-text-muted)', margin: '2px 0 8px' }}>
+        Created by the server, not uploaded by anyone. They count against no quota
+        and are rebuilt when needed — deleting them is safe.
+      </div>
+      <div style={{ display: 'flex', flexWrap: 'wrap', gap: '4px 20px' }}>
+        {items.map(i => (
+          <span key={i.prefix} style={{ fontSize: 11, color: 'var(--color-text-muted)' }}>
+            {derivedLabels[i.prefix] ?? i.prefix}:{' '}
+            <span style={{ color: 'var(--color-text)' }}>
+              {formatBytes(i.bytes)}
+            </span>{' '}
+            ({i.files})
+          </span>
+        ))}
+      </div>
+    </div>
   )
 }