Formkurve

Dein Training, an einem Ort.

Schlaf, Erholung, Belastung, Fahrten und Bestwerte aus deiner Garmin-Uhr. Dazu Kalender, Gym-Log, Kalorienzähler und Verschleiß deines Rads.

Warum du das selbst einrichtest

Garmin erlaubt nicht, dass du deinen persönlichen Schlüssel an jemand anderen weitergibst. Deshalb läuft dein Formkurve in deinem eigenen, kostenlosen Konto bei Cloudflare. Dein Schlüssel und deine Daten liegen nur dort. Niemand sonst kommt daran, auch nicht der Entwickler.

Mit Trainer oder Team teilen

Nur wenn du willst: Im Dashboard erstellst du einen Freigabe-Link und schickst ihn deinem Trainer. Wer ihn hat, kann deine Trainingsdaten lesen, aber nichts ändern. Schlaf und Erholung teilst du nur, wenn du das extra anhakst. Essen, Notizen und Gym bleiben immer privat. Du kannst die Freigabe jederzeit beenden, dann ist sofort Schluss.

Das brauchst du

eine Garmin-Uhr oder einen Garmin-Radcomputer mit Garmin-Connect-Konto
eine E-Mail-Adresse für das kostenlose Cloudflare-Konto
etwa 15 Minuten, am besten am Computer

In 5 Schritten einrichten

Cloudflare-Konto anlegen. Kostenlos. Bestätige danach die E-Mail.
Cloudflare öffnen ↗
Datenbank anlegen. Geh links auf Storage & Databases, dann D1 SQL database und Create Database. Nenn sie formkurve und wähle Create.
Worker anlegen. Geh auf Workers & Pages, dann Create application und Start with Hello World!. Nenn ihn formkurve und wähle Deploy.
Programm einfügen. Wähle Edit code (Symbol </>), lösche alles im Editor, füge den kopierten Text ein und wähle Deploy.
Datenbank verbinden. Geh zurück zum Worker, dann Bindings, Add binding und D1 database. Trag bei Variable name genau DB ein, wähle die Datenbank formkurve und bestätige.

Fertig

Öffne jetzt die Adresse deines Workers. Sie sieht so aus: https://formkurve.DEINNAME.workers.dev. Dort legst du dein Passwort fest und bekommst Schritt für Schritt erklärt, wie du deinen Garmin-Schlüssel erstellst. Danach ist das deine persönliche Formkurve-Adresse.

Die Menünamen bei Cloudflare können sich leicht ändern. Formkurve ist kein Produkt von Garmin und kein Medizinprodukt. Die Werte sind Orientierung, kein ärztlicher Rat. Deine Daten löschst du jederzeit selbst unter Profil, Einstellungen.

// Formkurve: dein eigener Speicher, läuft in deinem Cloudflare-Konto.
// Hier liegen dein Passwort-Hash, dein Garmin-Schlüssel und deine Daten. Niemand sonst hat Zugriff.
// Die Seite selbst kommt von SEITE; der Browser darf nur mit dieser Adresse hier reden (siehe CSP).

const SEITE = "https://formkurve.pages.dev/app.html";
const GARMIN = "https://personal.connectapi.garmin.com";
const TOKEN_PFAD = "/personalapitoken-service/personal-api/personal-api-key/token";
const SITZUNG_TAGE = 90;
const MAX_FEHLVERSUCHE = 10;
const SPERRE_MINUTEN = 15;
const MAX_DOKUMENT = 1_900_000;   // D1 erlaubt 2 MB pro Zeile

// Nur diese Garmin-Abrufe sind möglich, alle nur lesend
const ERLAUBT = /^\/(usersummary-service\/usersummary\/daily|usersummary-service\/v2\/dailysummaries|sleep-service\/sleep\/dailySleepSummariesByDate|hrv-service\/hrv\/daily\/[\d-]+\/[\d-]+|biometric-service\/heartRateZones\/v2|activitylist-service\/activities\/search\/activities|weight-service\/weight\/range\/[\d-]+\/[\d-]+|download-service\/files\/activity\/\d+)$/;

const CSP = "default-src 'none'; script-src 'unsafe-inline'; script-src-attr 'none'; style-src 'unsafe-inline'; img-src data: blob:; connect-src 'self'; form-action 'self'; base-uri 'none'; frame-ancestors 'none'";

const json = (daten, status = 200, kopf = {}) => new Response(JSON.stringify(daten), { status, headers: { "content-type": "application/json", "cache-control": "no-store", ...kopf } });
const fehler = (text, status = 400, mehr = {}) => json({ fehler: text, ...mehr }, status);
const hex = b => [...new Uint8Array(b)].map(x => x.toString(16).padStart(2, "0")).join("");
const sha = async s => hex(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(s)));
const zufall = () => hex(crypto.getRandomValues(new Uint8Array(32)));

const wert = async (env, k) => (await env.DB.prepare("SELECT v FROM werte WHERE k = ?").bind(k).first())?.v ?? null;
const setze = (env, k, v) => env.DB.prepare("INSERT INTO werte (k, v) VALUES (?, ?) ON CONFLICT (k) DO UPDATE SET v = excluded.v").bind(k, v).run();
const loesche = (env, k) => env.DB.prepare("DELETE FROM werte WHERE k = ?").bind(k).run();

let tabellenDa = null;
async function tabellen(env) {
  if (tabellenDa === env.DB) return;
  await env.DB.batch([
    env.DB.prepare("CREATE TABLE IF NOT EXISTS werte (k TEXT PRIMARY KEY, v TEXT NOT NULL)"),
    env.DB.prepare("CREATE TABLE IF NOT EXISTS sitzungen (hash TEXT PRIMARY KEY, bis INTEGER NOT NULL, rolle TEXT NOT NULL)"),
    env.DB.prepare("CREATE TABLE IF NOT EXISTS docs (coll TEXT NOT NULL, id TEXT NOT NULL, data TEXT NOT NULL, PRIMARY KEY (coll, id))"),
    env.DB.prepare("CREATE TABLE IF NOT EXISTS freigaben (hash TEXT PRIMARY KEY, id TEXT NOT NULL, name TEXT NOT NULL, umfang TEXT NOT NULL, seit INTEGER NOT NULL)"),
    env.DB.prepare("CREATE TABLE IF NOT EXISTS team (id TEXT PRIMARY KEY, name TEXT NOT NULL, url TEXT NOT NULL, token TEXT NOT NULL)"),
  ]);
  tabellenDa = env.DB;
}

// ---------- Anmeldung ----------
// Das Passwort verlässt den Browser nie: Er schickt nur einen daraus abgeleiteten Wert (PBKDF2), hier liegt dessen Hash.
function keks(req, inhalt, sekunden) {
  const sicher = new URL(req.url).protocol === "https:" ? "; Secure" : "";
  return `fk=${inhalt}; Path=/; HttpOnly; SameSite=Strict; Max-Age=${sekunden}${sicher}`;
}
async function neueSitzung(req, env, rolle) {
  const t = zufall(), bis = Date.now() + SITZUNG_TAGE * 864e5;
  await env.DB.batch([
    env.DB.prepare("DELETE FROM sitzungen WHERE bis < ?").bind(Date.now()),
    env.DB.prepare("INSERT INTO sitzungen (hash, bis, rolle) VALUES (?, ?, ?)").bind(await sha(t), bis, rolle),
  ]);
  return { "set-cookie": keks(req, t, SITZUNG_TAGE * 86400) };
}
// Rolle der Sitzung: "inhaber" darf alles, "trainer" nur die Team-Ansicht
async function angemeldet(req, env) {
  const t = (req.headers.get("cookie") || "").match(/(?:^|;\s*)fk=([0-9a-f]{64})/)?.[1];
  if (!t) return null;
  return (await env.DB.prepare("SELECT rolle FROM sitzungen WHERE hash = ? AND bis > ?").bind(await sha(t), Date.now()).first())?.rolle ?? null;
}
async function pruefeSchluessel(env, wertVomBrowser) {
  const sperre = +(await wert(env, "sperre_bis")) || 0;
  if (sperre > Date.now()) return { gesperrt: Math.ceil((sperre - Date.now()) / 6e4) };
  const h = await sha(String(wertVomBrowser));
  const rolle = h === (await wert(env, "passwort")) ? "inhaber" : h === (await wert(env, "trainer_passwort")) ? "trainer" : null;
  const fehl = rolle ? 0 : (+(await wert(env, "fehlversuche")) || 0) + 1;
  await setze(env, "fehlversuche", String(fehl >= MAX_FEHLVERSUCHE ? 0 : fehl));
  if (fehl >= MAX_FEHLVERSUCHE) await setze(env, "sperre_bis", String(Date.now() + SPERRE_MINUTEN * 6e4));
  return { rolle };
}

// ---------- Garmin ----------
async function garminToken(env, neu = false) {
  if (!neu) {
    const t = JSON.parse((await wert(env, "garmin_token")) || "null");
    if (t && t.bis - Date.now() > 36e5) return t.token;
  }
  return tauscheSchluessel(env, await wert(env, "garmin_schluessel"));
}
async function tauscheSchluessel(env, schluessel) {
  if (!schluessel) throw new Schluesselfehler();
  const r = await fetch(GARMIN + TOKEN_PFAD, { method: "POST", headers: { Accept: "*/*", Authorization: "ApiKey " + schluessel, "User-Agent": "Formkurve" } });
  if ([400, 401, 403, 404].includes(r.status)) throw new Schluesselfehler();
  if (!r.ok) throw new Error("Garmin antwortet nicht (" + r.status + ")");
  const token = (await r.text()).trim();
  let bis = Date.now() + 20 * 36e5;
  try { bis = JSON.parse(atob(token.split(".")[1].replace(/-/g, "+").replace(/_/g, "/"))).exp * 1000; } catch {}
  await setze(env, "garmin_token", JSON.stringify({ token, bis }));
  return token;
}
class Schluesselfehler extends Error {}

async function garminAbruf(req, env, url) {
  const pfad = url.pathname.slice("/api/garmin".length);
  if (req.method !== "GET" || !ERLAUBT.test(pfad)) return fehler("Dieser Abruf ist nicht erlaubt", 404);
  const hol = t => fetch(GARMIN + pfad + url.search, { headers: { Accept: "*/*", Authorization: "Bearer " + t, "User-Agent": "Formkurve" } });
  let r = await hol(await garminToken(env));
  if (r.status === 401) r = await hol(await garminToken(env, true));
  if (r.status === 401) throw new Schluesselfehler();   // sonst sähe es für die Seite wie eine abgelaufene Anmeldung aus
  return new Response(r.body, { status: r.status, headers: { "content-type": r.headers.get("content-type") || "application/octet-stream", "cache-control": "no-store" } });
}

// ---------- Daten ----------
const PFAD = /^([A-Za-z0-9_-]{1,60})\/([A-Za-z0-9_.:@+-]{1,160})$/;
async function dokument(req, env, url) {
  const m = PFAD.exec(url.searchParams.get("p") || "");
  if (!m) return fehler("Ungültiger Pfad");
  const [, coll, id] = m;
  if (req.method === "GET") {
    const z = await env.DB.prepare("SELECT data FROM docs WHERE coll = ? AND id = ?").bind(coll, id).first();
    return new Response(z ? z.data : "null", { headers: { "content-type": "application/json", "cache-control": "no-store" } });
  }
  if (req.method === "DELETE") { await env.DB.prepare("DELETE FROM docs WHERE coll = ? AND id = ?").bind(coll, id).run(); return json({ ok: true }); }
  const inhalt = await req.text();
  if (inhalt.length > MAX_DOKUMENT) return fehler("Dokument zu groß", 413);
  if (req.method === "PUT") {
    await env.DB.prepare("INSERT INTO docs (coll, id, data) VALUES (?, ?, ?) ON CONFLICT (coll, id) DO UPDATE SET data = excluded.data").bind(coll, id, inhalt).run();
    return json({ ok: true });
  }
  if (req.method === "PATCH") {
    const r = await env.DB.prepare("UPDATE docs SET data = json_patch(data, ?) WHERE coll = ? AND id = ?").bind(inhalt, coll, id).run();
    return r.meta?.changes ? json({ ok: true }) : fehler("Dokument fehlt", 404);
  }
  return fehler("Nicht erlaubt", 405);
}
async function sammlung(env, url) {
  const coll = url.searchParams.get("c") || "", feld = url.searchParams.get("order"), grenze = Math.min(+url.searchParams.get("limit") || 1000, 1000);
  if (!/^[A-Za-z0-9_-]{1,60}$/.test(coll) || (feld && !/^[a-z_]{1,40}$/.test(feld))) return fehler("Ungültige Abfrage");
  const richtung = url.searchParams.get("dir") === "desc" ? "DESC" : "ASC";
  const sql = feld ? `SELECT id, data FROM docs WHERE coll = ? ORDER BY json_extract(data, '$.${feld}') ${richtung} LIMIT ?` : "SELECT id, data FROM docs WHERE coll = ? LIMIT ?";
  const { results } = await env.DB.prepare(sql).bind(coll, grenze).all();
  // Von Hand zusammengesetzt: Die Daten sind schon JSON, nochmal umwandeln kostet nur Rechenzeit
  return new Response("[" + results.map(z => `{"id":${JSON.stringify(z.id)},"data":${z.data}}`).join(",") + "]", { headers: { "content-type": "application/json", "cache-control": "no-store" } });
}

// ---------- Freigaben: Der Besitzer entscheidet, wer seine Daten sehen darf ----------
// Ohne Freigabe kommt niemand an die Daten. Jede Freigabe lässt sich jederzeit beenden, gilt nur zum Lesen
// und enthält nie den Garmin-Schlüssel, Essen, Notizen oder das Gym-Log. Schlaf und Erholung nur auf ausdrücklichen Wunsch.
const NUR_MIT_GESUNDHEIT = ["sleep", "hrv", "hrvTrend", "bodyHist", "stats", "days"];
async function geteiltePerToken(env, token) {
  const f = /^[0-9a-f]{64}$/.test(token || "") ? await env.DB.prepare("SELECT name, umfang FROM freigaben WHERE hash = ?").bind(await sha(token)).first() : null;
  if (!f) return fehler("Freigabe beendet", 403);
  const z = await env.DB.prepare("SELECT data FROM docs WHERE coll = 'snapshot' AND id = 'latest'").first();
  const daten = z ? JSON.parse(z.data) : null;
  if (daten && f.umfang !== "alles") for (const k of NUR_MIT_GESUNDHEIT) delete daten[k];
  return json({ name: f.name, umfang: f.umfang, daten });
}
const geteilt = (req, env) => geteiltePerToken(env, (req.headers.get("authorization") || "").replace(/^Bearer /, ""));

async function freigaben(req, env, url) {
  if (req.method === "GET") return json((await env.DB.prepare("SELECT id, name, umfang, seit FROM freigaben ORDER BY seit").all()).results);
  if (req.method === "DELETE") { await env.DB.prepare("DELETE FROM freigaben WHERE id = ?").bind(url.searchParams.get("id") || "").run(); return json({ ok: true }); }
  if (req.method !== "POST") return fehler("Nicht erlaubt", 405);
  const { name, umfang } = await req.json(), n = String(name || "").trim().slice(0, 40);
  if (!n) return fehler("Bitte gib deinen Namen an.");
  const token = zufall(), id = zufall().slice(0, 12);
  await env.DB.prepare("INSERT INTO freigaben (hash, id, name, umfang, seit) VALUES (?, ?, ?, ?, ?)").bind(await sha(token), id, n, umfang === "alles" ? "alles" : "training", Date.now()).run();
  return json({ id, link: `${url.origin}/#freigabe=${token}` });   // nur jetzt lesbar, gespeichert ist nur der Hash
}

async function team(req, env, url, pfad, rolle) {
  if (pfad === "team") {
    if (req.method === "GET") return json((await env.DB.prepare("SELECT id, name, url FROM team ORDER BY name").all()).results);
    if (req.method !== "POST" || rolle !== "inhaber") return fehler("Das darf nur der Inhaber", 403);
    const m = /^(https:\/\/[^/#\s]+|http:\/\/localhost:\d+)\/?#freigabe=([0-9a-f]{64})$/.exec(String((await req.json()).link || "").trim());
    if (!m) return fehler("Das ist kein gültiger Freigabe-Link.");
    const [, ziel, token] = m;
    const r = await holeAthlet(env, url, ziel, token);
    if (!r.ok) return fehler(r.status === 403 ? "Diese Freigabe wurde beendet." : "Dieses Formkurve ist nicht erreichbar.");
    const { name } = await r.json(), id = zufall().slice(0, 12);
    await env.DB.prepare("DELETE FROM team WHERE url = ?").bind(ziel).run();
    await env.DB.prepare("INSERT INTO team (id, name, url, token) VALUES (?, ?, ?, ?)").bind(id, name, ziel, token).run();
    return json({ id, name });
  }
  const id = pfad.slice(5);
  if (req.method === "DELETE") {
    if (rolle !== "inhaber") return fehler("Das darf nur der Inhaber", 403);
    await env.DB.prepare("DELETE FROM team WHERE id = ?").bind(id).run();
    return json({ ok: true });
  }
  const m = await env.DB.prepare("SELECT url, token FROM team WHERE id = ?").bind(id).first();
  if (!m) return fehler("Unbekannt", 404);
  const r = await holeAthlet(env, url, m.url, m.token);
  return new Response(r.body, { status: r.status, headers: { "content-type": "application/json", "cache-control": "no-store" } });
}
// Ein Worker kann sich nicht selbst abrufen: Die eigene Freigabe kommt direkt aus der Datenbank
const holeAthlet = (env, url, ziel, token) => ziel === url.origin ? geteiltePerToken(env, token) : fetch(ziel + "/api/geteilt", { headers: { Authorization: "Bearer " + token, "User-Agent": "Formkurve" } });

// ---------- Seite ----------
async function seite() {
  let r;
  try { r = await fetch(SEITE, { cf: { cacheEverything: true, cacheTtl: 300 } }); } catch {}
  if (!r?.ok) return new Response("Die Formkurve-Seite ist gerade nicht erreichbar. Deine Daten sind sicher, versuch es später nochmal.", { status: 503, headers: { "content-type": "text/plain; charset=utf-8" } });
  return new Response(r.body, { headers: { "content-type": "text/html; charset=utf-8", "cache-control": "no-cache", "content-security-policy": CSP, "x-content-type-options": "nosniff", "referrer-policy": "no-referrer" } });
}

async function api(req, env, url) {
  const pfad = url.pathname.slice(5);
  if (pfad === "status") {
    const zugang = await wert(env, "passwort"), rolle = await angemeldet(req, env);
    return json({ db: true, eingerichtet: !!zugang, salz: await wert(env, "salz"), angemeldet: !!rolle, rolle, garmin: !!(await wert(env, "garmin_schluessel")), trainer: rolle === "inhaber" ? !!(await wert(env, "trainer_passwort")) : undefined });
  }
  if (req.method === "POST" && pfad === "konto") {
    // shortcut: Wer die Adresse als Erster öffnet, legt das Passwort fest; das Fenster ist nur die Minuten nach dem Einrichten offen
    if (await wert(env, "passwort")) return fehler("Das Passwort ist schon festgelegt", 409);
    const { schluessel, salz } = await req.json();
    if (!/^[0-9a-f]{64}$/.test(schluessel || "") || !/^[0-9a-f]{32}$/.test(salz || "")) return fehler("Ungültige Anfrage");
    await setze(env, "salz", salz);
    await setze(env, "passwort", await sha(schluessel));
    return json({ ok: true }, 200, await neueSitzung(req, env, "inhaber"));
  }
  if (pfad === "geteilt") return geteilt(req, env);
  if (req.method === "POST" && pfad === "anmelden") {
    const { schluessel } = await req.json();
    const e = await pruefeSchluessel(env, schluessel);
    if (e.gesperrt) return fehler(`Zu viele Versuche. Probier es in ${e.gesperrt} Minuten nochmal.`, 429);
    if (!e.rolle) return fehler("Falsches Passwort", 403);
    return json({ ok: true }, 200, await neueSitzung(req, env, e.rolle));
  }
  const rolle = await angemeldet(req, env);
  if (!rolle) return fehler("Bitte anmelden", 401);

  if (req.method === "POST" && pfad === "abmelden") {
    const t = (req.headers.get("cookie") || "").match(/(?:^|;\s*)fk=([0-9a-f]{64})/)?.[1];
    await env.DB.prepare("DELETE FROM sitzungen WHERE hash = ?").bind(await sha(t)).run();
    return json({ ok: true }, 200, { "set-cookie": keks(req, "", 0) });
  }
  if (pfad === "team" || pfad.startsWith("team/")) return team(req, env, url, pfad, rolle);
  if (rolle !== "inhaber") return fehler("Das darf nur der Inhaber", 403);   // Trainer sehen nur die Team-Ansicht

  if (pfad === "freigaben") return freigaben(req, env, url);
  if (pfad === "trainer") {
    await env.DB.prepare("DELETE FROM sitzungen WHERE rolle = 'trainer'").run();
    if (req.method === "DELETE") { await loesche(env, "trainer_passwort"); return json({ ok: true }); }
    if (req.method !== "PUT") return fehler("Nicht erlaubt", 405);
    const { schluessel } = await req.json();
    if (!/^[0-9a-f]{64}$/.test(schluessel || "")) return fehler("Ungültige Anfrage");
    const h = await sha(schluessel);
    if (h === (await wert(env, "passwort"))) return fehler("Der Trainer braucht ein anderes Passwort als du.");
    await setze(env, "trainer_passwort", h);
    return json({ ok: true });
  }
  if (pfad === "schluessel") {
    if (req.method === "DELETE") { await loesche(env, "garmin_schluessel"); await loesche(env, "garmin_token"); return json({ ok: true }); }
    if (req.method !== "PUT") return fehler("Nicht erlaubt", 405);
    const schluessel = String((await req.json()).schluessel || "").trim();
    if (!/^GCDC_\S{20,}$/.test(schluessel)) return fehler("Das sieht nicht wie ein Garmin-Schlüssel aus. Er beginnt mit GCDC_.");
    await tauscheSchluessel(env, schluessel);
    await setze(env, "garmin_schluessel", schluessel);
    return json({ ok: true });
  }
  if (req.method === "DELETE" && pfad === "alles") {
    const e = await pruefeSchluessel(env, (await req.json()).schluessel);
    if (e.rolle !== "inhaber") return fehler("Falsches Passwort", 403);
    await env.DB.batch(["docs", "werte", "sitzungen", "freigaben", "team"].map(t => env.DB.prepare("DELETE FROM " + t)));
    return json({ ok: true }, 200, { "set-cookie": keks(req, "", 0) });
  }
  if (pfad === "doc") return dokument(req, env, url);
  if (pfad === "col") return sammlung(env, url);
  if (pfad.startsWith("garmin/")) return garminAbruf(req, env, url);
  return fehler("Unbekannt", 404);
}

export default {
  async fetch(req, env) {
    const url = new URL(req.url);
    if (!url.pathname.startsWith("/api/")) return url.pathname === "/" ? seite() : new Response("Nicht gefunden", { status: 404 });
    if (!env.DB) return url.pathname === "/api/status" ? json({ db: false }) : fehler("Die Datenbank ist noch nicht verbunden", 503);
    const herkunft = req.headers.get("origin");
    if (req.method !== "GET" && herkunft && herkunft !== url.origin) return fehler("Fremde Herkunft", 403);
    try {
      await tabellen(env);
      return await api(req, env, url);
    } catch (e) {
      if (e instanceof Schluesselfehler) return fehler("Garmin nimmt den Schlüssel nicht an. Er ist abgelaufen, gelöscht oder falsch kopiert.", 409, { schluessel: true });
      return fehler("Fehler: " + (e.message || "unbekannt"), 502);
    }
  },
};