Merge branch 'phase/048-releases'

Bisher gab es nur Tags - eine Markierung im Verlauf. Eine Release ist ein
Eintrag in Gitea mit Titel und Beschreibung, sichtbar, abonnierbar,
verlinkbar.

npm run releases:sync liest das CHANGELOG, nimmt jeden Abschnitt, zu dem es
ein Tag gibt, und legt daraus eine Release an; ein zweiter Lauf aktualisiert
nur Geaendertes. "Unreleased" bleibt aussen vor, weil es dazu kein Tag gibt.
Fuenf Tests decken die Zerlegung ab.

Der Lauf gegen Gitea scheitert derzeit an den Zugangsdaten: Hinterlegt ist
ein elfstelliges Passwort, kein API-Token. Fuer Releases braucht es
write:repository, fuer den Issue-Abgleich issue:write.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

CHANGELOG.md

@@ -17,6 +17,11 @@ und dieses Projekt folgt [Semantic Versioning](https://semver.org/lang/de/).
 
 ### Sicherheit
 
+## [1.0.1] – 2026-10-25
+
+### Hinzugefügt
+- `npm run releases:sync` legt zu jedem Tag eine Release in Gitea an – Titel und Beschreibung stammen aus diesem CHANGELOG (#046)
+
 ## [1.0.0] – 2026-10-23
 
 Erste stabile Fassung. Kein neuer Funktionsumfang gegenüber 0.27.1 – was fehlte, war Erprobung, und

DEVLOG.md

@@ -73,7 +73,7 @@
 
 ## 2026-09-17 · Sitzung 1 · 19:36–laufend
 **Issue:** #001–#007 (Meilensteine v0.1.0 bis v0.4.0)
-**Version:** 1.0.0
+**Version:** 1.0.1
 
 ### Erledigt
 - Auftrag gelesen, Rückfragen gestellt
@@ -242,6 +242,10 @@
 - PMG wird zurückgestellt – kein Host im Betrieb. Die Lücke bleibt im Handbuch benannt, statt sie wegzudefinieren
 - Damit ist 1.0.0 gerechtfertigt: nicht weil nichts mehr fehlt, sondern weil das, was fehlte, erprobt wurde
 
+### 25.10.2026 – Releases
+- `releases:sync` gebaut: Das CHANGELOG ist die Quelle, Gitea bekommt daraus Releases zu den vorhandenen Tags
+- Dabei bestätigt, was beim Issue-Abgleich am 10.10. schon aufgefallen war: Der hinterlegte Zugang ist ein elfstelliges Passwort, kein API-Token. Pushen geht, die API nicht
+
 ### Nächster Schritt
 - #016 Benutzerhandbuch mit Screenshots, danach #017 Favicons und #019 CI-Pipeline
 - Für 1.0.0 fehlt noch: PMG (kein Host verfügbar) und der Fall „aktive Subscription auf PBS“ (#023)

README.md

@@ -175,9 +175,12 @@ npm run issues:sync -- --dry-run    # zeigt nur, was passieren würde
 npm run issues:sync                 # echter Abgleich
 ```
 
+Dasselbe gilt für Releases: `npm run releases:sync` legt zu jedem Tag einen Eintrag unter *Releases*
+an und nimmt den passenden Abschnitt aus dem CHANGELOG als Beschreibung (`--dry-run` zeigt es nur an).
+
 Serveradresse und Repository liest das Skript aus dem Git-Remote, den Token aus den hinterlegten
 Git-Zugangsdaten (Schlüsselbund oder `~/.git-credentials`) – derselbe Token wie fürs Pushen, er braucht
-zusätzlich das Recht `issue:write`. Wer beides trennen möchte, setzt `GITEA_URL`, `GITEA_REPO` und
+zusätzlich die Rechte `issue:write` (Issues) und `write:repository` (Releases). Wer beides trennen möchte, setzt `GITEA_URL`, `GITEA_REPO` und
 `GITEA_TOKEN` in der `.env`.
 
 Der Abgleich legt Labels und Meilensteine an, erkennt vorhandene Issues an der Nummer im Titel,

docs/issues/046-gitea-releases.md

@@ -0,0 +1,36 @@
+# #046 Releases in Gitea statt nur Tags
+**Status:** erledigt
+**Meilenstein:** v1.0.1
+**Labels:** chore, doku
+**Geschätzt:** 1 h   **Tatsächlich:** 0 h 25 min
+
+## Auslöser
+„Kannst du auch Releases machen und nicht nur Tags?“
+
+## Unterschied
+Ein Tag ist eine Markierung im Git-Verlauf. Eine **Release** ist ein Eintrag in Gitea mit Titel,
+Beschreibung und Download-Verweisen – sichtbar unter *Releases*, abonnierbar und verlinkbar.
+Bislang gab es nur Tags; die Beschreibungen standen allein im CHANGELOG.
+
+## Umsetzung
+`npm run releases:sync` liest das CHANGELOG, nimmt jeden Abschnitt `## [x.y.z] – Datum`, für den es
+ein Tag gibt, und legt daraus eine Release an. Ein zweiter Lauf aktualisiert nur, was sich geändert
+hat; „Unreleased“ bleibt außen vor, weil es dazu kein Tag gibt.
+
+```bash
+npm run releases:sync -- --dry-run    # zeigt nur, was passieren würde
+npm run releases:sync                 # legt an und aktualisiert
+npm run releases:sync -- v1.0.0       # nur eine Fassung
+```
+
+Fünf Tests decken die Zerlegung ab.
+
+## Offen: der Token
+Der in den Git-Zugangsdaten hinterlegte Wert ist elf Zeichen lang – ein Passwort, kein API-Token.
+Pushen funktioniert damit, die API antwortet mit 401. Betrifft auch `npm run issues:sync`, das seit
+dem 10.10.2026 nicht mehr durchläuft.
+
+**Nötig:** in Gitea unter *Einstellungen → Anwendungen* ein Token mit den Rechten
+`write:repository` (für Releases) und `issue:write` (für den Issue-Abgleich) erzeugen und entweder
+als `GITEA_TOKEN` in die `.env` legen oder in den Git-Zugangsdaten hinterlegen. Danach trägt ein
+einziger Lauf alle 43 vorhandenen Fassungen nach.

docs/issues/README.md

@@ -49,4 +49,5 @@ Details und Architektur: [../architektur.md](../architektur.md). Zeiten werden a
 | [#043](043-laufzeiten-bearbeiten.md) | Laufzeiten anlegen, bearbeiten, zusammenführen | erledigt | v0.25.0 | 4 h | 1 h 05 min |
 | [#044](044-eigenbedarf.md) | Eigene Hosts ohne Weiterberechnung | erledigt | v0.26.0 | 2 h | 0 h 40 min |
 | [#045](045-wiederherstellung-geprobt.md) | Wiederherstellung proben und Skript dafür | erledigt | v0.27.0 | 2 h | 0 h 50 min |
-| | **Summe** | | | **177 h** | **25 h 28 min** |
+| [#046](046-gitea-releases.md) | Releases in Gitea statt nur Tags | erledigt | v1.0.1 | 1 h | 0 h 25 min |
+| | **Summe** | | | **178 h** | **25 h 53 min** |

package.json

@@ -1,6 +1,6 @@
 {
   "name": "proxledger",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "private": true,
   "scripts": {
     "dev": "next dev",
@@ -27,7 +27,8 @@
     "screenshots": "node scripts/screenshots.mjs",
     "icons": "node scripts/icons.mjs",
     "pruefe:doku": "node scripts/pruefe-doku.mjs",
-    "benutzer": "tsx scripts/benutzer.ts"
+    "benutzer": "tsx scripts/benutzer.ts",
+    "releases:sync": "tsx scripts/gitea-releases.ts"
   },
   "dependencies": {
     "@node-rs/argon2": "^2.2.1",

scripts/gitea-releases.ts

@@ -0,0 +1,210 @@
+/**
+ * Legt zu jedem Git-Tag eine Release in Gitea an – mit dem passenden Abschnitt aus dem CHANGELOG
+ * als Beschreibung.
+ *
+ *   npm run releases:sync -- --dry-run    # zeigt nur, was passieren würde
+ *   npm run releases:sync                 # legt an und aktualisiert
+ *   npm run releases:sync -- v1.0.0       # nur diese eine Fassung
+ *
+ * Quelle der Wahrheit bleibt das CHANGELOG: Ein zweites Mal aufgerufen, wird eine vorhandene
+ * Release nur aktualisiert, wenn sich der Text geändert hat.
+ *
+ * Der Token braucht das Recht **write:repository** – `issue:write` allein genügt nicht. Er wird
+ * aus `GITEA_TOKEN` gelesen, sonst aus den Git-Zugangsdaten (#047).
+ */
+
+import { execFileSync } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import "dotenv/config";
+
+interface Fassung {
+  tag: string;
+  /** Überschrift ohne Klammern, z. B. „1.0.0 – 2026-10-23“. */
+  titel: string;
+  text: string;
+  datum: string | null;
+}
+
+interface Release {
+  id: number;
+  tag_name: string;
+  name: string;
+  body: string;
+}
+
+/** Zerlegt das CHANGELOG in seine Abschnitte je Fassung. */
+export function changelogZerlegen(inhalt: string): Fassung[] {
+  const zeilen = inhalt.split("\n");
+  const fassungen: Fassung[] = [];
+  let aktuell: Fassung | null = null;
+
+  for (const zeile of zeilen) {
+    // Überschriften der Form „## [1.0.0] – 2026-10-23“ (Keep a Changelog).
+    const kopf = /^##\s*\[([^\]]+)\]\s*[–-]?\s*(.*)$/.exec(zeile);
+    if (kopf) {
+      if (aktuell) fassungen.push(aktuell);
+      const nummer = kopf[1].trim();
+      const datum = kopf[2].trim() || null;
+      // „Unreleased“ hat kein Tag und gehört nicht als Release nach Gitea.
+      aktuell = /^\d/.test(nummer)
+        ? { tag: `v${nummer}`, titel: datum ? `${nummer} – ${datum}` : nummer, text: "", datum }
+        : null;
+      continue;
+    }
+    if (aktuell) aktuell.text += `${zeile}\n`;
+  }
+  if (aktuell) fassungen.push(aktuell);
+
+  return fassungen.map((fassung) => ({ ...fassung, text: fassung.text.trim() }));
+}
+
+function vorhandeneTags(): Set<string> {
+  const ausgabe = execFileSync("git", ["tag", "--list", "v*"], { encoding: "utf8" });
+  return new Set(ausgabe.split("\n").map((zeile) => zeile.trim()).filter(Boolean));
+}
+
+function ausRemote(): { basis: string; repo: string } | null {
+  try {
+    const url = execFileSync("git", ["remote", "get-url", "origin"], { encoding: "utf8" }).trim();
+    const treffer = /^https?:\/\/(?:[^@/]*@)?([^/]+)\/(.+?)(?:\.git)?$/.exec(url);
+    if (!treffer) return null;
+    return { basis: `https://${treffer[1]}`, repo: treffer[2] };
+  } catch {
+    return null;
+  }
+}
+
+/** Wie beim Issue-Abgleich: ein Token für Push und API, kein zweiter Eintrag in der .env. */
+function tokenAusGitCredentials(basis: string): string | null {
+  const host = new URL(basis).host;
+
+  for (const zusatz of [[], ["-c", "credential.helper=store"]]) {
+    try {
+      const antwort = execFileSync("git", [...zusatz, "credential", "fill"], {
+        input: `protocol=https\nhost=${host}\n\n`,
+        encoding: "utf8",
+        env: { ...process.env, GIT_TERMINAL_PROMPT: "0" },
+        stdio: ["pipe", "pipe", "ignore"],
+      });
+      const passwort = /^password=(.*)$/m.exec(antwort);
+      if (passwort?.[1]) return passwort[1];
+    } catch {
+      // Nächste Möglichkeit versuchen.
+    }
+  }
+
+  return null;
+}
+
+class Gitea {
+  constructor(
+    private readonly basis: string,
+    private readonly repo: string,
+    private readonly token: string,
+  ) {}
+
+  private async anfrage<T>(pfad: string, optionen: RequestInit = {}): Promise<T> {
+    const antwort = await fetch(`${this.basis}/api/v1/repos/${this.repo}${pfad}`, {
+      ...optionen,
+      headers: {
+        Authorization: `token ${this.token}`,
+        "Content-Type": "application/json",
+        ...optionen.headers,
+      },
+    });
+
+    if (!antwort.ok) {
+      const text = await antwort.text();
+      const hinweis =
+        antwort.status === 401 || antwort.status === 403
+          ? "\n  Der Token braucht das Recht „write:repository“. Gitea: Einstellungen → Anwendungen → Token erzeugen."
+          : "";
+      throw new Error(`Gitea antwortet mit ${antwort.status} auf ${pfad}: ${text}${hinweis}`);
+    }
+
+    // Beim Löschen kommt 204 ohne Inhalt zurück.
+    return antwort.status === 204 ? (undefined as T) : ((await antwort.json()) as T);
+  }
+
+  releases() {
+    return this.anfrage<Release[]>("/releases?limit=100");
+  }
+
+  anlegen(daten: { tag_name: string; name: string; body: string }) {
+    return this.anfrage<Release>("/releases", { method: "POST", body: JSON.stringify(daten) });
+  }
+
+  aktualisieren(id: number, daten: { name: string; body: string }) {
+    return this.anfrage<Release>(`/releases/${id}`, { method: "PATCH", body: JSON.stringify(daten) });
+  }
+}
+
+async function main() {
+  const trockenlauf = process.argv.includes("--dry-run");
+  const nurFassung = process.argv.slice(2).find((wert) => /^v?\d+\.\d+\.\d+$/.test(wert));
+
+  const remote = ausRemote();
+  const basis = (process.env.GITEA_URL ?? remote?.basis ?? "").replace(/\/$/, "");
+  const repo = process.env.GITEA_REPO ?? remote?.repo ?? "";
+
+  if (!basis || !repo) {
+    console.error("Kein Gitea-Ziel gefunden. GITEA_URL und GITEA_REPO setzen oder ein Remote einrichten.");
+    process.exit(1);
+  }
+
+  const changelog = await readFile(path.join(process.cwd(), "CHANGELOG.md"), "utf8");
+  const tags = vorhandeneTags();
+
+  // Nur Fassungen, zu denen es auch ein Tag gibt – eine Release ohne Tag wäre eine Behauptung.
+  let fassungen = changelogZerlegen(changelog).filter((fassung) => tags.has(fassung.tag));
+  if (nurFassung) {
+    const gesucht = nurFassung.startsWith("v") ? nurFassung : `v${nurFassung}`;
+    fassungen = fassungen.filter((fassung) => fassung.tag === gesucht);
+  }
+
+  console.log(`Ziel: ${basis}/${repo}`);
+  console.log(`${fassungen.length} Fassung(en) mit Tag im CHANGELOG.`);
+
+  const token = process.env.GITEA_TOKEN ?? tokenAusGitCredentials(basis);
+  if (trockenlauf || !token) {
+    if (!token && !trockenlauf) {
+      console.log("\nKein Token gefunden – es folgt nur ein Trockenlauf.");
+      console.log("Ein Token mit dem Recht „write:repository“ gehört in GITEA_TOKEN.");
+    }
+    for (const fassung of fassungen) {
+      console.log(`  ${fassung.tag}: „${fassung.titel}“ (${fassung.text.split("\n").length} Zeilen)`);
+    }
+    return;
+  }
+
+  const gitea = new Gitea(basis, repo, token);
+  const vorhanden = new Map((await gitea.releases()).map((release) => [release.tag_name, release]));
+
+  for (const fassung of fassungen) {
+    const alt = vorhanden.get(fassung.tag);
+
+    if (!alt) {
+      if (!trockenlauf) {
+        await gitea.anlegen({ tag_name: fassung.tag, name: fassung.titel, body: fassung.text });
+      }
+      console.log(`Angelegt:     ${fassung.tag}`);
+      continue;
+    }
+
+    if (alt.body.trim() === fassung.text && alt.name === fassung.titel) {
+      console.log(`Unverändert:  ${fassung.tag}`);
+      continue;
+    }
+
+    if (!trockenlauf) await gitea.aktualisieren(alt.id, { name: fassung.titel, body: fassung.text });
+    console.log(`Aktualisiert: ${fassung.tag}`);
+  }
+
+  console.log("\nAbgleich abgeschlossen.");
+}
+
+main().catch((fehler: unknown) => {
+  console.error(fehler instanceof Error ? fehler.message : fehler);
+  process.exit(1);
+});

tests/gitea-releases.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+import { changelogZerlegen } from "../scripts/gitea-releases";
+
+/** Zerlegung des CHANGELOG in Release-Abschnitte (#046). */
+
+const BEISPIEL = `# Changelog
+
+Alle wesentlichen Änderungen.
+
+## [Unreleased]
+
+- noch nichts
+
+## [1.0.0] – 2026-10-23
+
+Erste stabile Fassung.
+
+### Hinzugefügt
+- Dies und das
+
+## [0.27.1] – 2026-10-23
+
+### Sicherheit
+- Next.js angehoben
+`;
+
+describe("CHANGELOG zerlegen", () => {
+  it("findet die Fassungen mit Datum", () => {
+    const fassungen = changelogZerlegen(BEISPIEL);
+    expect(fassungen.map((f) => f.tag)).toEqual(["v1.0.0", "v0.27.1"]);
+    expect(fassungen[0].titel).toBe("1.0.0 – 2026-10-23");
+  });
+
+  it("übergeht „Unreleased“ – dazu gibt es kein Tag", () => {
+    expect(changelogZerlegen(BEISPIEL).some((f) => f.tag.includes("Unreleased"))).toBe(false);
+  });
+
+  it("nimmt den Text bis zur nächsten Überschrift mit", () => {
+    const [eins] = changelogZerlegen(BEISPIEL);
+    expect(eins.text).toContain("Erste stabile Fassung.");
+    expect(eins.text).toContain("### Hinzugefügt");
+    expect(eins.text).not.toContain("0.27.1");
+  });
+
+  it("schneidet Leerzeilen an den Rändern ab", () => {
+    const [eins] = changelogZerlegen(BEISPIEL);
+    expect(eins.text.startsWith("Erste")).toBe(true);
+    expect(eins.text.endsWith("Dies und das")).toBe(true);
+  });
+
+  it("kommt mit einem Changelog ohne Fassungen zurecht", () => {
+    expect(changelogZerlegen("# Changelog\n\nNoch nichts veröffentlicht.\n")).toEqual([]);
+  });
+});