Dashboard fuer Kollegen auf Cloudflare Pages

veroeffentlichen.sh baut mit werkzeuge/pages_bauen.py den Ordner .pages
und laedt ihn nach hivegrid-marketing.pages.dev. Die Middleware in
werkzeuge/pages/ uebernimmt Passwort, nur lesen und die Auskuenfte von
serve.py (Dokumente, Stand, Suche). Der Tunnel bleibt als Notloesung.
Anleitung in .docs/Freigabe.md, Hinweis fuer Agents in .claude/CLAUDE.md.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
dejanandClaude Opus 5.5 committed 2026-10-20 14:31:57 +02:00
1 parent 64da152d53
commit e112597568
6 files changed
+265 -35

No files matched your search

+93
View File
@@ -0,0 +1,93 @@
// Cloudflare Pages: das Dashboard für Kollegen, ohne Dejans Laptop.
//
// Läuft vor jeder Anfrage und macht, was serve.py und freigabe.py lokal tun:
// - jede Anfrage braucht das Passwort (Pages-Secret PASSWORT), der Name ist egal
// - nur lesen: Status setzen, Export und Öffnen antworten mit 403
// - "/" zeigt das Dashboard
// - /api/dokumente, /api/stand und /api/suche kommen aus festen Dateien in
// pages-daten/, die werkzeuge/pages_bauen.py beim Hochladen erzeugt
//
// Hochgeladen wird mit ./veroeffentlichen.sh, Anleitung in .docs/Freigabe.md.
const NUR_LESEN = { fehler: "In der Freigabe lässt sich nichts ändern." };
export async function onRequest({ request, env, next }) {
if (!erlaubt(request, env.PASSWORT)) {
return new Response("Passwort nötig", {
status: 401,
headers: { "WWW-Authenticate": 'Basic realm="HiveGrid Marketing", charset="UTF-8"' },
});
}
const url = new URL(request.url);
if (request.method !== "GET" && request.method !== "HEAD") return json(403, NUR_LESEN);
if (url.pathname === "/" || url.pathname === "/index.html") return asset(env, url, "/Dashboard/");
if (url.pathname === "/api/dokumente") return asset(env, url, "/pages-daten/dokumente.json");
if (url.pathname === "/api/stand") return asset(env, url, "/pages-daten/stand.json");
if (url.pathname === "/api/suche") return suche(env, url);
const antwort = await next();
// Markdown als Text mit Umlauten, so wie serve.py es ausliefert.
if (url.pathname.endsWith(".md") && antwort.ok) {
const neu = new Response(antwort.body, antwort);
neu.headers.set("Content-Type", "text/markdown; charset=utf-8");
return neu;
}
return antwort;
}
function erlaubt(request, passwort) {
if (!passwort) return false;
const kopf = request.headers.get("Authorization") || "";
if (!kopf.startsWith("Basic ")) return false;
let pw = "";
try {
const roh = Uint8Array.from(atob(kopf.slice(6)), (z) => z.charCodeAt(0));
const text = new TextDecoder().decode(roh);
pw = text.slice(text.indexOf(":") + 1);
} catch {
return false;
}
// Immer alle Zeichen vergleichen, damit die Antwortzeit nichts verrät.
let unterschied = pw.length ^ passwort.length;
for (let i = 0; i < passwort.length; i++) unterschied |= (pw.charCodeAt(i) || 0) ^ passwort.charCodeAt(i);
return unterschied === 0;
}
async function asset(env, url, pfad) {
const antwort = await env.ASSETS.fetch(new URL(pfad, url));
const neu = new Response(antwort.body, antwort);
neu.headers.set("Cache-Control", "no-store");
return neu;
}
// Wie _suche in serve.py: Zeile für Zeile, ohne Groß- und Kleinschreibung,
// mit der letzten Überschrift davor, höchstens 300 Treffer.
async function suche(env, url) {
const q = (url.searchParams.get("q") || "").trim();
if (q.length < 2) return json(200, []);
const index = await (await env.ASSETS.fetch(new URL("/pages-daten/suche.json", url))).json();
const gesucht = q.toLowerCase();
const treffer = [];
for (const dok of index) {
let ueberschrift = "";
for (let i = 0; i < dok.zeilen.length; i++) {
const zeile = dok.zeilen[i];
if (zeile.startsWith("#")) ueberschrift = zeile.replace(/^#+/, "").trim();
const pos = zeile.toLowerCase().indexOf(gesucht);
if (pos < 0) continue;
const a = Math.max(0, pos - 70);
const text = (a ? "…" : "") + zeile.slice(a, pos + q.length + 90).trim();
treffer.push({ pfad: dok.pfad, titel: dok.titel, zeile: i + 1, ueberschrift, text });
if (treffer.length >= 300) return json(200, treffer);
}
}
return json(200, treffer);
}
function json(status, daten) {
return new Response(JSON.stringify(daten), {
status,
headers: { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" },
});
}
+94
View File
@@ -0,0 +1,94 @@
#!/usr/bin/env python3
"""Baut den Ordner .pages/ für Cloudflare Pages.
.pages/public/ alle Dateien, die git kennt, im Stand der Arbeitskopie
.pages/functions/ die Middleware aus werkzeuge/pages/ (Passwort, nur lesen, API)
Weggelassen wird, was mit einem Punkt beginnt (.git, .docs, .claude), die
Server-Skripte oben im Hub und alles über 25 MB, mehr nimmt Pages nicht an.
Dazu kommen in public/pages-daten/ die Auskünfte, die lokal serve.py
liefert: Dokumentenliste, Stand und der Index für die Suche. Gleiche Auswahl
der Dokumente wie in serve.py, aber nur die, die auch hochgeladen werden.
Aufgerufen von ./veroeffentlichen.sh.
"""
import json
import shutil
import subprocess
import sys
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
import serve # noqa: E402
HUB = serve.HUB
ZIEL = HUB / ".pages"
GRENZE = 25 * 1024 * 1024
SERVER = {"serve.py", "serve.sh", "freigabe.py", "freigabe.sh", "veroeffentlichen.sh"}
NICHT_GEFUNDEN = """<!doctype html>
<html lang="de"><meta charset="utf-8"><title>Nicht gefunden</title>
<body style="font-family: system-ui, sans-serif; padding: 40px">
<h1>Nicht gefunden</h1><p><a href="/">Zum Dashboard</a></p></body></html>
"""
def bekannte_dateien():
roh = subprocess.run(["git", "ls-files", "-z"], cwd=HUB, capture_output=True, check=True).stdout
for rel in filter(None, roh.decode("utf-8").split("\0")):
rel = serve.nfc(rel)
teile = rel.split("/")
if any(t.startswith(".") for t in teile) or "node_modules" in teile or rel in SERVER:
continue
pfad = HUB / rel
if not pfad.is_file():
continue # in der Arbeitskopie gelöscht
if pfad.stat().st_size > GRENZE:
print("Zu groß für Pages, fehlt dort: %s" % rel)
continue
yield rel, pfad
def main():
if ZIEL.exists():
shutil.rmtree(ZIEL)
oeffentlich = ZIEL / "public"
hochgeladen = set()
for rel, pfad in bekannte_dateien():
ziel = oeffentlich / rel
ziel.parent.mkdir(parents=True, exist_ok=True)
shutil.copy2(pfad, ziel)
hochgeladen.add(rel)
dokumente, index = [], []
for p in serve.markdown_dateien():
rel = serve.nfc(p.relative_to(HUB).as_posix())
if rel not in hochgeladen:
continue
titel = serve.titel_von(p)
dokumente.append({"pfad": rel, "titel": titel,
"ordner": str(Path(rel).parent) if "/" in rel else "",
"zeit": serve.mtime(p)})
index.append({"pfad": rel, "titel": titel, "zeilen": p.read_text(encoding="utf-8").split("\n")})
daten = max([serve.mtime(p) for p in serve.DATEN.glob("*.json")] or [0.0])
neueste = max([d["zeit"] for d in dokumente] or [0.0])
stand = {"daten": daten, "dokumente": neueste, "aenderung": max(daten, neueste)}
auskunft = oeffentlich / "pages-daten"
auskunft.mkdir(parents=True)
for name, inhalt in (("dokumente", dokumente), ("stand", stand), ("suche", index)):
(auskunft / (name + ".json")).write_text(json.dumps(inhalt, ensure_ascii=False), encoding="utf-8")
# Ohne 404.html hält Pages die Seite für eine Single-Page-App und liefert
# für fehlende Dateien die Startseite statt eines Fehlers.
(oeffentlich / "404.html").write_text(NICHT_GEFUNDEN, encoding="utf-8")
funktionen = ZIEL / "functions"
funktionen.mkdir(parents=True)
shutil.copy2(HUB / "werkzeuge" / "pages" / "_middleware.js", funktionen / "_middleware.js")
print("Gebaut: %d Dateien, %d Dokumente in %s" % (len(hochgeladen), len(dokumente), ZIEL))
if __name__ == "__main__":
main()