Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
  florian.wildeandClaude Opus 5
|
7b60667633 | ||
|
florian.wildeandClaude Opus 5
|
a122187feb | ||
|
florian.wildeandClaude Opus 5
|
1fe41ac2a5 | ||
|
florian.wildeandClaude Opus 5
|
c270038edd | ||
|
florian.wildeandClaude Opus 5
|
e1d435f10a | ||
|
florian.wildeandClaude Opus 5
|
6a7365946b |
+6
-1
@@ -69,9 +69,14 @@ ADMINER_PORT="127.0.0.1:8080"
|
||||
# und Passkeys sind davon nicht betroffen.
|
||||
APP_SECRET="bitte-aendern-mindestens-32-zeichen-langer-zufallswert"
|
||||
|
||||
# Lebensdauer einer Anmeldung in Tagen.
|
||||
# Absolute Lebensdauer einer Anmeldung in Tagen – ab dem Anmelden gerechnet
|
||||
# und nicht verlaengerbar.
|
||||
SESSION_TTL_DAYS="30"
|
||||
|
||||
# Leerlauffrist in Stunden: so lange darf eine Sitzung unbenutzt bleiben.
|
||||
# Wird bei jeder Nutzung neu angestossen. 0 schaltet die Pruefung ab.
|
||||
SESSION_IDLE_HOURS="8"
|
||||
|
||||
# ── Benachrichtigungen ───────────────────────────────────────
|
||||
# ntfy und Webhook brauchen nichts weiter – die Ziele werden in der
|
||||
# Anwendung unter "Mein Konto" eingerichtet.
|
||||
|
||||
+120
-2
@@ -22,8 +22,19 @@ sonst würden Konten ausgesperrt. Nach der Einrichtung ist `/setup` dauerhaft ge
|
||||
|
||||
### 0.2 Anmeldung
|
||||
|
||||
- **Benutzername und Passwort.** Mindestens 10 Zeichen, offensichtliche Passwörter werden
|
||||
abgelehnt. Hashing mit scrypt.
|
||||
- **Benutzername und Passwort.** Mindestens 10 Zeichen. Abgelehnt werden naheliegende
|
||||
Passwörter, reine Ziffernfolgen, zu wenig verschiedene Zeichen (`abababab`),
|
||||
durchlaufende Folgen (`abcdefgh`) und alles, was den eigenen Benutzernamen enthält.
|
||||
**Keine Zusammensetzungsregeln** — ASVS 2.1.9 rät ausdrücklich davon ab, weil sie zu
|
||||
`Passwort1!` führen statt zu Entropie.
|
||||
- **Hashing mit scrypt**, `N = 2^17, r = 8, p = 1` nach dem OWASP Password Storage Cheat
|
||||
Sheet (rund 0,5 s und 128 MiB je Prüfung). Die Parameter stehen im Hash, ältere bleiben
|
||||
also lesbar — und werden bei der nächsten Anmeldung still auf den aktuellen Stand
|
||||
gehoben. Das ist der einzige Moment, in dem das Klartextpasswort vorliegt.
|
||||
- **Gleiche Antwort für alles Fehlgeschlagene.** Ob ein Konto existiert, gesperrt,
|
||||
deaktiviert oder reines Passkey-Konto ist, sagt die Anmeldung erst, wenn das Passwort
|
||||
stimmt. Davor gibt es genau einen Text und eine vergleichbare Antwortzeit
|
||||
(`fakeVerifyDelay`), damit sich Benutzernamen nicht durchprobieren lassen.
|
||||
- **Passkey (WebAuthn).** Fingerabdruck, Gesichtserkennung oder Sicherheitsschlüssel. Die
|
||||
Anmeldung läuft über auffindbare Credentials, ein Benutzername ist also nicht nötig.
|
||||
Mehrere Passkeys pro Konto, benennbar und einzeln entfernbar.
|
||||
@@ -503,6 +514,103 @@ Dateneinsicht. Ein Administrator sieht dadurch weiterhin keine fremden Projekte.
|
||||
- **Zeitlimit** pro Aufruf über `GIT_API_TIMEOUT_MS` einstellbar; die Teilabfragen laufen
|
||||
parallel, eine fehlschlagende Liste bricht den restlichen Sync nicht ab.
|
||||
|
||||
### 4.6 Aufgabe ↔ Git-Issue
|
||||
|
||||
Die Verbindung geht in beide Richtungen — mit einer bewussten Grenze.
|
||||
|
||||
**Nebula → Git.** Ein Knopf im Aufgabendialog legt zur Aufgabe ein Issue im
|
||||
verknüpften Repository an. Nummer und Adresse landen an der Aufgabe (`sourceIssue`,
|
||||
`sourceUrl`, `sourceRepositoryId` — dieselben Felder, die die Übernahme aus Issues seit
|
||||
v0.9.0 füllt, samt Eindeutigkeit je Repository gegen Dubletten). In den Rumpf kommt ein
|
||||
Rückverweis auf das Projekt.
|
||||
|
||||
Ausdrücklich **per Knopf und nie nebenbei**: was in ein fremdes System geschrieben wird,
|
||||
soll jemand gewollt haben. Danach wandert der Zustand allerdings mit — erledigt schließt
|
||||
das Issue, ein Zurückziehen öffnet es wieder. Schlägt der Aufruf fehl, zieht die Aufgabe
|
||||
trotzdem um; ein nicht erreichbares Git-System darf das Abhaken nicht verhindern.
|
||||
|
||||
**Git → Nebula** auf zwei Wegen, die sich ergänzen:
|
||||
|
||||
- **Webhook** — sofort, sobald das Issue geschlossen wird. Setzt voraus, dass die Instanz
|
||||
von außen erreichbar ist und der Haken eingetragen wurde (siehe 4.7).
|
||||
- **Beim Abgleich** — verzögert, aber verlässlich. Der Abgleich fragt den Zustand
|
||||
verknüpfter Issues nach und hakt ab, was in Git geschlossen ist. Damit funktioniert der
|
||||
Rückweg auch ohne Webhook, ohne öffentliche Erreichbarkeit und selbst dann, wenn ein
|
||||
Haken einmal ausfällt.
|
||||
|
||||
Gespart wird, wo es geht: Nummern, die der gerade geholte Snapshot als offen führt,
|
||||
werden nicht einzeln nachgefragt. Umgekehrt gilt das nicht — die Liste der offenen
|
||||
Issues ist gedeckelt, aus dem Fehlen einer Nummer folgt also nichts. Pro Durchgang
|
||||
fragt der Abgleich höchstens 25 Issues nach.
|
||||
|
||||
**Der Abgleich hakt nur ab, er nimmt nie zurück.** Er sieht Zustände, keine Ereignisse:
|
||||
ein offenes Issue kann auch bedeuten, dass das Schließen von Nebula aus fehlgeschlagen
|
||||
ist. Ein symmetrischer Abgleich würde dann eine bewusst erledigte Aufgabe wieder
|
||||
aufmachen. Das Zurücknehmen bleibt dem Webhook vorbehalten, der ein echtes „reopened“
|
||||
sieht.
|
||||
|
||||
Ein gelöschtes Issue ist kein erledigtes — die Aufgabe bleibt stehen.
|
||||
|
||||
In beiden Fällen bewirkt ein geschlossenes Issue dasselbe wie ein Haken in der
|
||||
Oberfläche: bei einer wiederkehrenden Aufgabe entsteht die nächste Fassung, und der
|
||||
Vorgang landet im Projektverlauf (ohne Benutzer — das hat nicht jemand in Nebula getan,
|
||||
sondern das Git-System gemeldet).
|
||||
|
||||
**Die Zustände passen nicht aufeinander, und das bleibt so.** Nebula kennt
|
||||
`Offen · In Arbeit · Blockiert · Erledigt`, ein Issue nur offen oder geschlossen. Nach
|
||||
außen geht deshalb nur die Grenze um „erledigt“; ein Rundlauf verliert *In Arbeit* und
|
||||
*Blockiert*. Labels wie `nebula:doing` wären die Alternative, würden aber den
|
||||
Issue-Tracker mit Zuständen füllen, die dort niemand pflegt. Die feine Abstufung bleibt
|
||||
in Nebula.
|
||||
|
||||
Eine echte beidseitige Synchronisation mit Konfliktauflösung gibt es **nicht** — das ist
|
||||
der klassische Ort für stillen Datenverlust.
|
||||
|
||||
**Kein Widerspruch zu „keine eigenen Git-Operationen“:** Issues laufen über die HTTP-API
|
||||
der Provider, dieselbe Schicht wie alles andere (`lib/git/http.ts`, SSRF-Schutz
|
||||
inklusive). Kein Klon, kein Arbeitsverzeichnis. Schreibende Aufrufe folgen dabei
|
||||
**keinen Umleitungen** — ein 307 auf eine interne Adresse nähme den Rumpf und den Token
|
||||
im Header mit.
|
||||
|
||||
### 4.7 Webhooks
|
||||
|
||||
Ein Push aktualisiert den Stand sofort, statt bis zum nächsten Durchlauf des Zeitgebers
|
||||
zu warten; ein geschlossenes Issue hakt seine Aufgabe ab. Der Zeitplan bleibt als
|
||||
Rückfalllösung bestehen.
|
||||
|
||||
Einzurichten am Repository (Funksymbol im Git-Bereich): Nebula erzeugt URL und
|
||||
Geheimnis, eingetragen wird der Haken im Git-System von Hand. Über die API anzulegen
|
||||
wäre machbar, verlangte aber Administrationsrechte am Repository — deutlich mehr, als
|
||||
Nebula sonst braucht.
|
||||
|
||||
Das Geheimnis ist **genau einmal** zu sehen; danach liegt es verschlüsselt in der
|
||||
Datenbank, wie die Zugangstoken, und verlässt den Server nicht mehr.
|
||||
|
||||
| System | Ausweis | Kopfzeile |
|
||||
| --- | --- | --- |
|
||||
| GitHub | HMAC-SHA256 über den Rumpf | `X-Hub-Signature-256: sha256=…` |
|
||||
| Gitea | dieselbe Rechnung, ohne Präfix | `X-Gitea-Signature` (ältere: `X-Hub-Signature-256`) |
|
||||
| GitLab | das Geheimnis im Klartext | `X-Gitlab-Token` |
|
||||
|
||||
GitLabs Verfahren ist schwächer: es beweist nur, dass der Absender das Geheimnis kennt,
|
||||
nicht dass der Rumpf unverändert ist. Mehr gibt die Plattform nicht her; verglichen wird
|
||||
trotzdem zeitkonstant.
|
||||
|
||||
Geprüft wird gegen den **rohen** Rumpf — durch `JSON.parse` und `JSON.stringify` gedreht
|
||||
käme eine andere Zeichenfolge heraus und die Signatur passte nie.
|
||||
|
||||
Was der Endpunkt bewusst **nicht** tut: den Rumpf als Quelle für Inhalte benutzen. Titel,
|
||||
Beschreibung und Zustand kommen weiter aus Nebula beziehungsweise beim nächsten Abgleich
|
||||
aus der API. Wer das Geheimnis kennt, kann also höchstens eine Aufgabe auf- oder zumachen
|
||||
und einen Abgleich auslösen — keine beliebigen Daten einschleusen.
|
||||
|
||||
Unbekannte Ereignisse werden angenommen und liegen gelassen. Ein Fehler brächte das
|
||||
Git-System zum Wiederholen und irgendwann zum Abschalten des Hakens.
|
||||
|
||||
Der Endpunkt ist der einzige ohne Anmeldung, der schreibt. Deshalb: Ratenbegrenzung je
|
||||
Repository (60/Minute), Deckel auf die Rumpfgröße, und ein unbekanntes Repository
|
||||
antwortet wie ein nicht eingerichtetes — mit 404, damit die ID nicht bestätigt wird.
|
||||
|
||||
---
|
||||
|
||||
## 4a. Export, Import und Sicherung
|
||||
@@ -688,6 +796,16 @@ nicht verloren gehen. Indizes auf Status, Verbindung und Änderungsdatum.
|
||||
`GIT_BLOCK_PRIVATE` und `GIT_ALLOWED_HOSTS`.
|
||||
- **Rate-Limiting** für Anmeldung (je IP und je Konto), ausgehende Git-Aufrufe und
|
||||
WebAuthn-Optionen.
|
||||
- **Sitzungen**: Zufallstoken mit 256 Bit, in der Datenbank nur als SHA-256-Hash — wer die
|
||||
Datenbank liest, kann keine Sitzung übernehmen. Geprüft wird bei jeder Anfrage, Abmelden
|
||||
und Sperren wirken also sofort. Zwei Fristen nach ASVS 3.3.2: **absolut** 30 Tage ab
|
||||
Anmeldung (`SESSION_TTL_DAYS`) und **im Leerlauf** 8 Stunden (`SESSION_IDLE_HOURS`).
|
||||
Ein Passwortwechsel entwertet alle Sitzungen und stellt für das eigene Gerät eine neue
|
||||
aus.
|
||||
- **Cookies**: `HttpOnly`, `SameSite=Strict`, `Secure` sobald die App über HTTPS läuft, und
|
||||
dann zusätzlich mit dem Präfix `__Host-`. Der Präfix lässt den Browser selbst erzwingen,
|
||||
dass kein `Domain` gesetzt ist — eine andere Subdomain kann den Cookie damit nicht
|
||||
überschreiben und keine Sitzung unterschieben.
|
||||
- Access Tokens verschlüsselt mit **AES-256-GCM**, Schlüssel per **scrypt** aus
|
||||
`APP_SECRET` abgeleitet, Chiffrat versioniert (`v1.<iv>.<tag>.<data>`).
|
||||
- Tokens werden nie an den Browser gesendet — alle API-Antworten nutzen eine Feldauswahl
|
||||
|
||||
@@ -118,7 +118,8 @@ Alle Variablen sind in [`.env.example`](.env.example) dokumentiert.
|
||||
| `APP_URL` | Öffentliche Adresse — bestimmt die WebAuthn-RP-ID | `http://localhost:3000` |
|
||||
| `DATABASE_URL` | PostgreSQL-Verbindung (Prisma) | `postgresql://nebula:nebula@localhost:5432/nebula` |
|
||||
| `APP_SECRET` | Schlüssel für die Token-Verschlüsselung (AES-256-GCM) | — **unbedingt setzen** |
|
||||
| `SESSION_TTL_DAYS` | Lebensdauer einer Anmeldung in Tagen | `30` |
|
||||
| `SESSION_TTL_DAYS` | Absolute Lebensdauer einer Anmeldung in Tagen | `30` |
|
||||
| `SESSION_IDLE_HOURS` | Nach so vielen Stunden ohne Nutzung läuft die Sitzung ab (`0` = aus) | `8` |
|
||||
| `PORT` | Port der Anwendung | `3000` |
|
||||
| `APP_PORT` | Host-Port-Mapping des App-Containers | `127.0.0.1:3000` |
|
||||
| `POSTGRES_USER` / `POSTGRES_PASSWORD` / `POSTGRES_DB` | Zugangsdaten des DB-Containers | `nebula` |
|
||||
|
||||
+13
-47
@@ -27,15 +27,6 @@ Migration wert.
|
||||
|
||||
---
|
||||
|
||||
### 1.1 Webhooks statt Polling `M`
|
||||
|
||||
Ein Push aktualisiert den Snapshot sofort, statt bis zum nächsten Durchlauf
|
||||
zu warten. Braucht einen öffentlich erreichbaren Endpunkt mit
|
||||
Signaturprüfung je Provider — sinnvoll erst, wenn die Instanz von außen
|
||||
erreichbar ist. Der Zeitplan bleibt als Rückfalllösung.
|
||||
|
||||
---
|
||||
|
||||
### 1.2 Läuft es noch? `M`
|
||||
|
||||
Eine Health-Check-URL je Projekt, die der Zeitgeber regelmäßig anpingt.
|
||||
@@ -52,47 +43,21 @@ Sitzungen.
|
||||
|
||||
---
|
||||
|
||||
### 1.4 v1.7.0 „Aufgaben und Issues" `M` + `M`
|
||||
### 1.4 Aufgaben ↔ Issues: was noch fehlt `S`
|
||||
|
||||
Nachverfolgbarkeit zwischen Nebula-Aufgabe und Git. Die Zuordnung steht im
|
||||
Schema bereits: `sourceIssue`, `sourceUrl`, `sourceRepositoryId` samt
|
||||
`@@unique`. Die Richtung **Git → Nebula** gibt es seit v0.9.0
|
||||
(`tasks/from-issues`); es fehlt die Gegenrichtung.
|
||||
Mit v1.7.0 stehen beide Richtungen: „als Issue anlegen“ und der Rückweg über
|
||||
Webhooks. Offen geblieben ist Kleinkram:
|
||||
|
||||
**Kein Widerspruch zu „Bewusst nicht".** Ausgeschlossen sind dort *eigene
|
||||
Git-Operationen* — klonen, committen, pushen. Issues laufen über die
|
||||
HTTP-API der Provider, dieselbe Schicht wie alles andere (`lib/git/http.ts`,
|
||||
SSRF-Schutz inklusive). Kein Klon, kein Arbeitsverzeichnis.
|
||||
- **Mehrere Repositories.** Der Knopf nimmt immer das führende. Bei einem
|
||||
Projekt aus Frontend und Backend fehlt die Wahl.
|
||||
- **Beim Übernehmen aus Issues** wird der Rückweg nicht automatisch
|
||||
eingerichtet — der Webhook ist getrennt zu setzen.
|
||||
|
||||
Warum Issues und nicht eine Datei im Repo: **dort verlinkt Git ohnehin.**
|
||||
Ein `fixes #12` in der Commit-Nachricht stellt die Verbindung von selbst
|
||||
her — die Kette Aufgabe → Commit → PR gibt es geschenkt, statt sie zu bauen.
|
||||
Damit erledigt sich auch „Aufgabe ↔ Commit verknüpfen" aus Abschnitt 3.
|
||||
|
||||
**Stufe 1 — eine Richtung, ausdrücklich** `M`
|
||||
Ein Knopf „als Issue anlegen" an der Aufgabe. Nummer und URL wandern in die
|
||||
vorhandenen Felder. Kein Automatismus: was nach außen geht, wird
|
||||
angestoßen, nicht nebenbei mitgeschrieben.
|
||||
|
||||
**Stufe 2 — Rückweg über Webhooks** `M`
|
||||
Setzt 1.1 voraus. Geschlossenes Issue → Aufgabe nach `DONE`. Erst damit ist
|
||||
„synchron" ehrlich, ohne im Minutentakt fremde APIs zu fragen.
|
||||
|
||||
**Die Zustände passen nicht aufeinander, und das bleibt so.** Nebula kennt
|
||||
`TODO/DOING/BLOCKED/DONE`, ein Issue nur offen/geschlossen. Ein Rundlauf
|
||||
verliert also `DOING` und `BLOCKED` — bewusst hingenommen: die feine
|
||||
Abstufung bleibt in Nebula, nach Git geht nur offen/zu. Labels wie
|
||||
`nebula:doing` wären die Alternative, würden aber den Issue-Tracker mit
|
||||
Zuständen zumüllen, die dort niemand pflegt.
|
||||
|
||||
**Echte beidseitige Synchronisation mit Konfliktauflösung ist nicht
|
||||
vorgesehen.** Das ist der klassische Ort für stillen Datenverlust, und für
|
||||
ein persönliches Dashboard steht der Aufwand in keinem Verhältnis.
|
||||
|
||||
Für Projekte ohne Issue-Tracker wäre eine `.nebula/tasks.md` über die
|
||||
Contents-API denkbar — aber nur als **einseitiger Spiegel**, nicht als
|
||||
Synchronisation: zwei Schreiber auf einer Datei, und jede Statusänderung
|
||||
ein Commit.
|
||||
Was **nicht** kommt, bleibt wie besprochen: eine echte beidseitige
|
||||
Synchronisation mit Konfliktauflösung. Die Zustände passen ohnehin nicht
|
||||
aufeinander — ein Issue kennt nur offen und geschlossen, `DOING` und
|
||||
`BLOCKED` gehen im Rundlauf verloren. Das ist hingenommen, statt den
|
||||
Issue-Tracker mit Labels zu füllen, die dort niemand pflegt.
|
||||
|
||||
---
|
||||
|
||||
@@ -172,6 +137,7 @@ Damit klar ist, was **nicht** kommt und warum:
|
||||
| **v1.4.0** README-Vorschau auf der Projektseite | ✓ |
|
||||
| **v1.5.0** Sicherheitsdurchsicht, Server-Anleitung und Update-Skript | ✓ |
|
||||
| **v1.6.0** Mobile Ansicht, Listenansicht, Schnellerfassung, Aufgaben über alle Projekte | ✓ |
|
||||
| **v1.7.0** Aufgabe als Git-Issue anlegen, Webhooks für Push und Issues | ✓ |
|
||||
|
||||
Zur Entscheidung beim Export: Git-Tokens gehen **nicht** mit. Die Verbindung wird nur
|
||||
beschrieben, das Token ist nach dem Import neu zu hinterlegen. Snapshots bleiben
|
||||
|
||||
+231
@@ -1,4 +1,13 @@
|
||||
import { expect, test, type APIRequestContext } from "@playwright/test";
|
||||
import { PrismaClient } from "@prisma/client";
|
||||
|
||||
/**
|
||||
* Dieselbe Datenbank wie global-setup.ts. Gebraucht fuer den einen Fall, in
|
||||
* dem ein Zustand herzustellen ist, den die API bewusst nicht anbietet.
|
||||
*/
|
||||
const DATABASE_URL =
|
||||
process.env.E2E_DATABASE_URL ??
|
||||
"postgresql://nebula:nebula@localhost:5432/nebula_e2e_test?schema=public";
|
||||
|
||||
/**
|
||||
* Tests ueber HTTP gegen die laufende Anwendung – also durch Middleware,
|
||||
@@ -279,6 +288,228 @@ test("Mehrere Repositories je Projekt", async ({ request, playwright }) => {
|
||||
expect(zumSchluss.repositories[0].repoName).toBe("swr");
|
||||
});
|
||||
|
||||
test("Die Anmeldung verraet nicht, welche Konten es gibt", async ({ request, playwright }) => {
|
||||
await login(request, ADMIN);
|
||||
|
||||
// Ein Konto anlegen und stilllegen.
|
||||
const angelegt = await request.post("/api/admin/users", {
|
||||
data: {
|
||||
username: "stillgelegt",
|
||||
password: "ein-ausreichend-langes-passwort",
|
||||
role: "USER",
|
||||
},
|
||||
});
|
||||
expect(angelegt.status()).toBe(201);
|
||||
const id = (await angelegt.json()).user.id;
|
||||
expect((await request.patch(`/api/admin/users/${id}`, { data: { isActive: false } })).ok())
|
||||
.toBeTruthy();
|
||||
|
||||
const anonym = await playwright.request.newContext({
|
||||
baseURL: test.info().project.use.baseURL,
|
||||
});
|
||||
|
||||
// Falsches Passwort auf dem stillgelegten Konto ...
|
||||
const stillgelegt = await anonym.post("/api/auth/login", {
|
||||
data: { username: "stillgelegt", password: "falsches-passwort-hier" },
|
||||
});
|
||||
// ... und auf einem Konto, das es gar nicht gibt.
|
||||
const erfunden = await anonym.post("/api/auth/login", {
|
||||
data: { username: "gibtesnicht", password: "falsches-passwort-hier" },
|
||||
});
|
||||
|
||||
// Beides muss ununterscheidbar sein – sonst laesst sich durchprobieren,
|
||||
// welche Benutzernamen vergeben sind. Frueher kam hier 403 gegen 401.
|
||||
expect(stillgelegt.status()).toBe(erfunden.status());
|
||||
expect(stillgelegt.status()).toBe(401);
|
||||
expect(await stillgelegt.json()).toEqual(await erfunden.json());
|
||||
|
||||
// Mit dem richtigen Passwort darf die Anwendung dann Klartext reden.
|
||||
const mitPasswort = await anonym.post("/api/auth/login", {
|
||||
data: { username: "stillgelegt", password: "ein-ausreichend-langes-passwort" },
|
||||
});
|
||||
expect(mitPasswort.status()).toBe(403);
|
||||
expect((await mitPasswort.json()).error).toMatch(/deaktiviert/);
|
||||
|
||||
await anonym.dispose();
|
||||
await request.delete(`/api/admin/users/${id}`);
|
||||
});
|
||||
|
||||
test("Abgleich hakt Aufgaben ab, deren Issue geschlossen wurde", async ({ request }) => {
|
||||
await login(request, ADMIN);
|
||||
|
||||
// Ein oeffentliches Repository mit sicher geschlossenen Issues. Der
|
||||
// Abgleich laeuft anonym gegen die GitHub-API – kein Token noetig.
|
||||
const projekt = (
|
||||
await (
|
||||
await request.post("/api/projects", {
|
||||
data: { name: "Rueckweg", repoUrl: "https://github.com/vercel/swr" },
|
||||
})
|
||||
).json()
|
||||
).project;
|
||||
const repoId = projekt.repositories[0].id;
|
||||
|
||||
const angelegt = await request.post(`/api/projects/${projekt.id}/tasks`, {
|
||||
data: { title: "Haengt an einem geschlossenen Issue" },
|
||||
});
|
||||
const taskId = (await angelegt.json()).task.id;
|
||||
|
||||
/**
|
||||
* Die Verknuepfung direkt in der Datenbank setzen.
|
||||
*
|
||||
* Ueber die API gibt es dafuer keinen Weg, und das ist richtig so: "als
|
||||
* Issue anlegen" wuerde ein neues Issue in einem fremden Repository
|
||||
* erzeugen. Ein Endpunkt nur fuer Tests waere eine Hintertuer im
|
||||
* Produktionscode – dafuer greift der Test lieber selbst zur Datenbank.
|
||||
*
|
||||
* Issue 1 von vercel/swr ist seit Jahren geschlossen.
|
||||
*/
|
||||
const prisma = new PrismaClient({
|
||||
datasources: { db: { url: DATABASE_URL } },
|
||||
});
|
||||
try {
|
||||
await prisma.task.update({
|
||||
where: { id: taskId },
|
||||
data: { sourceRepositoryId: repoId, sourceIssue: 1 },
|
||||
});
|
||||
} finally {
|
||||
await prisma.$disconnect();
|
||||
}
|
||||
|
||||
const vorher = await (await request.get(`/api/projects/${projekt.id}`)).json();
|
||||
const alsAngelegt = vorher.project.tasks.find(
|
||||
(t: { id: string }) => t.id === taskId,
|
||||
);
|
||||
expect(alsAngelegt.sourceIssue).toBe(1);
|
||||
expect(alsAngelegt.status).toBe("TODO");
|
||||
|
||||
// Abgleich anstossen – er fragt den Zustand des Issues nach.
|
||||
const sync = await request.post(`/api/repositories/${repoId}/sync`);
|
||||
const syncBody = await sync.json();
|
||||
|
||||
/**
|
||||
* Dieser Test greift als einziger wirklich nach draussen. Ist GitHub nicht
|
||||
* erreichbar oder das anonyme Rate-Limit ausgeschoepft, sagt er das statt
|
||||
* rot zu werden – ein fremder Dienst darf die Testreihe nicht bestimmen.
|
||||
*/
|
||||
if (!sync.ok()) {
|
||||
test.skip(true, `GitHub nicht erreichbar: ${syncBody.message ?? sync.status()}`);
|
||||
return;
|
||||
}
|
||||
|
||||
const nachher = await (await request.get(`/api/projects/${projekt.id}`)).json();
|
||||
const abgehakt = nachher.project.tasks.find((t: { id: string }) => t.id === taskId);
|
||||
expect(abgehakt.status).toBe("DONE");
|
||||
expect(abgehakt.doneAt).not.toBeNull();
|
||||
|
||||
// Und ein zweiter Lauf aendert nichts mehr – abgehakt bleibt abgehakt,
|
||||
// ohne dass erneut nachgefragt wird.
|
||||
const nochmal = await request.post(`/api/repositories/${repoId}/sync`);
|
||||
expect((await nochmal.json()).message ?? "").not.toMatch(/abgehakt/);
|
||||
});
|
||||
|
||||
test("Webhook: Signatur entscheidet, sonst passiert nichts", async ({ request, playwright }) => {
|
||||
await login(request, ADMIN);
|
||||
|
||||
const projekt = (
|
||||
await (
|
||||
await request.post("/api/projects", {
|
||||
data: { name: "Hakenprojekt", repoUrl: "https://github.com/vercel/swr" },
|
||||
})
|
||||
).json()
|
||||
).project;
|
||||
const repoId = projekt.repositories[0].id;
|
||||
|
||||
// Ohne eingerichteten Webhook ist der Endpunkt stumm – und zwar mit 404,
|
||||
// damit die ID nicht bestaetigt wird.
|
||||
const ohne = await request.post(`/api/webhooks/${repoId}`, {
|
||||
headers: { "Content-Type": "application/json" },
|
||||
data: { action: "closed", issue: { number: 1 } },
|
||||
});
|
||||
expect(ohne.status()).toBe(404);
|
||||
|
||||
// Einrichten liefert das Geheimnis genau einmal zurueck.
|
||||
const eingerichtet = await request.post(`/api/repositories/${repoId}/webhook`);
|
||||
expect(eingerichtet.status()).toBe(200);
|
||||
const { secret, url } = await eingerichtet.json();
|
||||
expect(typeof secret).toBe("string");
|
||||
expect(secret.length).toBeGreaterThanOrEqual(64);
|
||||
expect(url).toContain(`/api/webhooks/${repoId}`);
|
||||
|
||||
// Und danach nirgends mehr: weder im Projekt noch am Repository.
|
||||
const geladen = await (await request.get(`/api/projects/${projekt.id}`)).json();
|
||||
expect(JSON.stringify(geladen)).not.toContain(secret);
|
||||
expect(geladen.project.repositories[0].webhookSecret).toBeUndefined();
|
||||
|
||||
// Eine Aufgabe, die an einem Issue haengt – von Hand gesetzt gibt es
|
||||
// nicht, also ueber die Uebernahme aus dem Snapshot. Stattdessen prueft
|
||||
// dieser Test die Grenze selbst: ohne gueltige Signatur passiert nichts.
|
||||
const rumpf = JSON.stringify({ action: "closed", issue: { number: 4242 } });
|
||||
|
||||
const falsch = await request.post(`/api/webhooks/${repoId}`, {
|
||||
headers: {
|
||||
"Content-Type": "application/json",
|
||||
"X-GitHub-Event": "issues",
|
||||
"X-Hub-Signature-256": "sha256=00",
|
||||
},
|
||||
data: rumpf,
|
||||
});
|
||||
expect(falsch.status()).toBe(401);
|
||||
|
||||
const gar_keine = await request.post(`/api/webhooks/${repoId}`, {
|
||||
headers: { "Content-Type": "application/json", "X-GitHub-Event": "issues" },
|
||||
data: rumpf,
|
||||
});
|
||||
expect(gar_keine.status()).toBe(401);
|
||||
|
||||
// Mit richtiger Signatur wird der Aufruf angenommen. Zu Issue 4242 gibt
|
||||
// es keine Aufgabe – erwartet ist also "angenommen, nichts zugeordnet".
|
||||
const { createHmac } = await import("node:crypto");
|
||||
const signatur = createHmac("sha256", secret).update(rumpf, "utf8").digest("hex");
|
||||
const richtig = await request.post(`/api/webhooks/${repoId}`, {
|
||||
headers: {
|
||||
"Content-Type": "application/json",
|
||||
"X-GitHub-Event": "issues",
|
||||
"X-Hub-Signature-256": `sha256=${signatur}`,
|
||||
},
|
||||
data: rumpf,
|
||||
});
|
||||
expect(richtig.status()).toBe(200);
|
||||
const antwort = await richtig.json();
|
||||
expect(antwort).toMatchObject({ ok: true, handled: "issue", matched: false });
|
||||
|
||||
// Dieselbe Signatur zu einem anderen Rumpf gilt nicht.
|
||||
const veraendert = await request.post(`/api/webhooks/${repoId}`, {
|
||||
headers: {
|
||||
"Content-Type": "application/json",
|
||||
"X-GitHub-Event": "issues",
|
||||
"X-Hub-Signature-256": `sha256=${signatur}`,
|
||||
},
|
||||
data: JSON.stringify({ action: "closed", issue: { number: 9999 } }),
|
||||
});
|
||||
expect(veraendert.status()).toBe(401);
|
||||
|
||||
// Fremde Konten koennen den Haken weder einrichten noch zuruecknehmen.
|
||||
const fremd = await playwright.request.newContext({
|
||||
baseURL: test.info().project.use.baseURL,
|
||||
});
|
||||
await login(fremd, ZWEITER);
|
||||
expect((await fremd.post(`/api/repositories/${repoId}/webhook`)).status()).toBe(404);
|
||||
expect((await fremd.delete(`/api/repositories/${repoId}/webhook`)).status()).toBe(404);
|
||||
await fremd.dispose();
|
||||
|
||||
// Zuruecknehmen schliesst den Endpunkt wieder.
|
||||
expect((await request.delete(`/api/repositories/${repoId}/webhook`)).ok()).toBeTruthy();
|
||||
const danach = await request.post(`/api/webhooks/${repoId}`, {
|
||||
headers: {
|
||||
"Content-Type": "application/json",
|
||||
"X-GitHub-Event": "issues",
|
||||
"X-Hub-Signature-256": `sha256=${signatur}`,
|
||||
},
|
||||
data: rumpf,
|
||||
});
|
||||
expect(danach.status()).toBe(404);
|
||||
});
|
||||
|
||||
test("Brett: Reihenfolge und Mehrfachauswahl", async ({ request, playwright }) => {
|
||||
await login(request, ADMIN);
|
||||
|
||||
|
||||
@@ -163,6 +163,46 @@ test("Schnellerfassung legt Idee und Aufgabe mit einem Feld an", async ({ page }
|
||||
await expect(page.getByText("Aus der Bahn notiert")).toBeVisible();
|
||||
});
|
||||
|
||||
test("Dialoge weichen der Bildschirmtastatur aus", async ({ page }) => {
|
||||
await page.setViewportSize({ width: 375, height: 667 });
|
||||
await page.getByRole("button", { name: "Schnell erfassen" }).click();
|
||||
await expect(page.getByRole("dialog")).toBeVisible();
|
||||
|
||||
const TASTATUR = 336;
|
||||
|
||||
/**
|
||||
* Eine echte Tastatur laesst sich nicht einblenden. Stattdessen meldet
|
||||
* visualViewport eine kleinere Hoehe – genau die Schnittstelle, an der
|
||||
* der Dialog haengt. Ueberschrieben wird am echten Objekt: der Dialog
|
||||
* merkt sich beim Oeffnen eine Referenz darauf.
|
||||
*/
|
||||
await page.evaluate((tastatur) => {
|
||||
const fenster = window.visualViewport;
|
||||
if (!fenster) throw new Error("visualViewport fehlt");
|
||||
const hoehe = window.innerHeight - tastatur;
|
||||
Object.defineProperty(fenster, "height", { get: () => hoehe, configurable: true });
|
||||
Object.defineProperty(fenster, "offsetTop", { get: () => 0, configurable: true });
|
||||
fenster.dispatchEvent(new Event("resize"));
|
||||
}, TASTATUR);
|
||||
|
||||
await page.waitForTimeout(300);
|
||||
|
||||
// Eingabefeld und Absendeknopf muessen oberhalb der Tastatur liegen.
|
||||
// Vorher stand der Dialog mittig im vollen Fenster – und damit zur
|
||||
// Haelfte darunter.
|
||||
const frei = 667 - TASTATUR;
|
||||
for (const ziel of [
|
||||
page.locator("#quick-title"),
|
||||
page.getByRole("dialog").getByRole("button", { name: "Anlegen" }),
|
||||
]) {
|
||||
const kasten = await ziel.boundingBox();
|
||||
expect(kasten).not.toBeNull();
|
||||
expect(kasten!.y + kasten!.height).toBeLessThanOrEqual(frei);
|
||||
}
|
||||
|
||||
await page.keyboard.press("Escape");
|
||||
});
|
||||
|
||||
test("Aufgabenuebersicht sammelt ueber alle Projekte und hakt ab", async ({ page }) => {
|
||||
await page.getByRole("link", { name: "Aufgaben", exact: true }).click();
|
||||
await expect(page.getByRole("heading", { name: "Aufgaben", level: 1 })).toBeVisible();
|
||||
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "nebula",
|
||||
"version": "1.6.0",
|
||||
"version": "1.9.0",
|
||||
"private": true,
|
||||
"description": "Nebula – Dashboard fuer Vibe-Coding Projekte mit Git-Anbindung (GitHub, GitLab, Gitea)",
|
||||
"scripts": {
|
||||
|
||||
@@ -0,0 +1,3 @@
|
||||
-- AlterTable
|
||||
ALTER TABLE "Repository" ADD COLUMN "webhookLastAt" TIMESTAMP(3),
|
||||
ADD COLUMN "webhookSecret" TEXT;
|
||||
@@ -407,6 +407,16 @@ model Repository {
|
||||
notifiedCiState String?
|
||||
notifiedRelease String?
|
||||
|
||||
/// Gemeinsames Geheimnis fuer eingehende Webhooks, verschluesselt wie die
|
||||
/// Zugangstoken. Je Repository, weil der Haken im Git-System dort
|
||||
/// eingetragen wird und sich einzeln zuruecknehmen laesst.
|
||||
/// NULL heisst: fuer dieses Repository ist kein Webhook eingerichtet, und
|
||||
/// eingehende Aufrufe werden abgewiesen.
|
||||
webhookSecret String?
|
||||
/// Wann zuletzt ein gueltiger Webhook ankam – die einzige Rueckmeldung
|
||||
/// darueber, ob der Haken im Git-System wirklich funktioniert.
|
||||
webhookLastAt DateTime?
|
||||
|
||||
snapshot RepoSnapshot?
|
||||
|
||||
createdAt DateTime @default(now())
|
||||
|
||||
@@ -47,7 +47,7 @@ export async function POST(request: Request) {
|
||||
}
|
||||
}
|
||||
|
||||
const weak = validatePasswordStrength(parsed.data.newPassword);
|
||||
const weak = validatePasswordStrength(parsed.data.newPassword, user.username);
|
||||
if (weak) {
|
||||
return NextResponse.json({ error: weak, fields: { newPassword: weak } }, { status: 422 });
|
||||
}
|
||||
|
||||
@@ -69,7 +69,7 @@ export async function PATCH(request: Request, { params }: Params) {
|
||||
}
|
||||
|
||||
if (password) {
|
||||
const weak = validatePasswordStrength(password);
|
||||
const weak = validatePasswordStrength(password, target.username);
|
||||
if (weak) {
|
||||
return NextResponse.json({ error: weak, fields: { password: weak } }, { status: 422 });
|
||||
}
|
||||
|
||||
@@ -47,7 +47,7 @@ export async function POST(request: Request) {
|
||||
|
||||
const { username, displayName, email, password, role } = parsed.data;
|
||||
|
||||
const weak = validatePasswordStrength(password);
|
||||
const weak = validatePasswordStrength(password, username);
|
||||
if (weak) {
|
||||
return NextResponse.json({ error: weak, fields: { password: weak } }, { status: 422 });
|
||||
}
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
import { NextResponse } from "next/server";
|
||||
import { createPendingLogin, setMfaCookie } from "@/lib/auth/mfa";
|
||||
import { fakeVerifyDelay, verifyPassword } from "@/lib/auth/password";
|
||||
import { fakeVerifyDelay, hashPassword, needsRehash, verifyPassword } from "@/lib/auth/password";
|
||||
import { createSession, setSessionCookie } from "@/lib/auth/session";
|
||||
import { lockRemainingSeconds, noteFailedLogin, noteSuccessfulLogin } from "@/lib/auth/users";
|
||||
import { prisma } from "@/lib/db";
|
||||
@@ -42,6 +42,30 @@ export async function POST(request: Request) {
|
||||
return jsonError(GENERIC, 401);
|
||||
}
|
||||
|
||||
/**
|
||||
* Erst das Passwort pruefen, dann ueber den Kontozustand reden.
|
||||
*
|
||||
* Frueher standen die Abfragen auf gesperrt, deaktiviert und
|
||||
* "kein Passwort hinterlegt" **vor** der Pruefung und beantworteten sich
|
||||
* damit ohne jede Kenntnis des Passworts. Wer einen Benutzernamen riet,
|
||||
* bekam an der Antwort gesagt, ob es ihn gibt – genau die Aufzaehlbarkeit,
|
||||
* die der einheitliche Text GENERIC sonst verhindert.
|
||||
*
|
||||
* Jetzt gilt: falsches Passwort → immer dieselbe Antwort. Die
|
||||
* hilfreichere Auskunft bekommt nur, wer das Passwort kennt.
|
||||
*/
|
||||
const valid = user.passwordHash
|
||||
? await verifyPassword(password, user.passwordHash)
|
||||
: // Kein Passwort hinterlegt (reines Passkey-Konto): trotzdem Zeit
|
||||
// verbrennen, damit sich der Fall nicht an der Antwortdauer zeigt.
|
||||
await fakeVerifyDelay().then(() => false);
|
||||
|
||||
if (!valid) {
|
||||
// Fehlversuche nur zaehlen, wo es ein Passwort zu erraten gibt.
|
||||
if (user.passwordHash) await noteFailedLogin(user.id);
|
||||
return jsonError(GENERIC, 401);
|
||||
}
|
||||
|
||||
const locked = lockRemainingSeconds(user.lockedUntil);
|
||||
if (locked > 0) {
|
||||
return jsonError(
|
||||
@@ -51,22 +75,20 @@ export async function POST(request: Request) {
|
||||
}
|
||||
|
||||
if (!user.isActive) {
|
||||
await fakeVerifyDelay();
|
||||
return jsonError("Dieses Konto ist deaktiviert.", 403);
|
||||
}
|
||||
|
||||
if (!user.passwordHash) {
|
||||
await fakeVerifyDelay();
|
||||
return jsonError(
|
||||
"Fuer dieses Konto ist kein Passwort hinterlegt – bitte mit Passkey anmelden.",
|
||||
401,
|
||||
);
|
||||
}
|
||||
|
||||
const valid = await verifyPassword(password, user.passwordHash);
|
||||
if (!valid) {
|
||||
await noteFailedLogin(user.id);
|
||||
return jsonError(GENERIC, 401);
|
||||
/**
|
||||
* Der Aufwand beim Hashen ist gestiegen. Wer sich mit einem Passwort
|
||||
* anmeldet, dessen Hash noch nach den alten Vorgaben erzeugt wurde,
|
||||
* bekommt hier still einen neuen – es ist der einzige Moment, in dem das
|
||||
* Klartextpasswort vorliegt. Nebenlaeufig, damit die Anmeldung nicht auf
|
||||
* die halbe Sekunde wartet.
|
||||
*/
|
||||
if (needsRehash(user.passwordHash)) {
|
||||
void hashPassword(password)
|
||||
.then((neu) => prisma.user.update({ where: { id: user.id }, data: { passwordHash: neu } }))
|
||||
.catch(() => undefined);
|
||||
}
|
||||
|
||||
// Das Passwort stimmt. Ist ein zweiter Faktor eingerichtet, entsteht hier
|
||||
|
||||
@@ -39,7 +39,7 @@ export async function POST(request: Request) {
|
||||
|
||||
const { username, displayName, email, password } = parsed.data;
|
||||
|
||||
const weak = validatePasswordStrength(password);
|
||||
const weak = validatePasswordStrength(password, username);
|
||||
if (weak) {
|
||||
return NextResponse.json({ error: weak, fields: { password: weak } }, { status: 422 });
|
||||
}
|
||||
|
||||
@@ -34,7 +34,7 @@ export async function POST(request: Request) {
|
||||
|
||||
const { username, displayName, email, password, mode } = parsed.data;
|
||||
|
||||
const weak = validatePasswordStrength(password);
|
||||
const weak = validatePasswordStrength(password, username);
|
||||
if (weak) {
|
||||
return NextResponse.json(
|
||||
{ error: weak, fields: { password: weak } },
|
||||
|
||||
@@ -0,0 +1,63 @@
|
||||
import { randomBytes } from "node:crypto";
|
||||
import { NextResponse } from "next/server";
|
||||
import { requireUserApi } from "@/lib/auth/guard";
|
||||
import { APP_URL } from "@/lib/config";
|
||||
import { encryptSecret } from "@/lib/crypto";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { ownedRepository } from "@/lib/repositories";
|
||||
import { jsonError } from "@/lib/security/request";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
type Params = { params: Promise<{ id: string }> };
|
||||
|
||||
/**
|
||||
* Richtet den Webhook eines Repositories ein oder nimmt ihn zurueck.
|
||||
*
|
||||
* Das Geheimnis wird hier erzeugt und **genau einmal** im Klartext
|
||||
* zurueckgegeben – danach liegt es nur noch verschluesselt in der Datenbank,
|
||||
* wie die Zugangstoken. Wer es verliert, erzeugt ein neues; das alte gilt
|
||||
* dann nicht mehr.
|
||||
*
|
||||
* Eingetragen wird der Haken im Git-System von Hand. Ihn ueber die API
|
||||
* anzulegen waere machbar, verlangte aber Administrationsrechte am
|
||||
* Repository – deutlich mehr, als Nebula sonst braucht.
|
||||
*/
|
||||
export async function POST(_request: Request, { params }: Params) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const { id } = await params;
|
||||
const repository = await ownedRepository(id, auth.user.id);
|
||||
if (!repository) return jsonError("Repository nicht gefunden", 404);
|
||||
|
||||
// 32 Byte, hexadezimal. Lang genug, dass Raten aussichtslos ist, und
|
||||
// ohne Sonderzeichen, die in Formularfeldern Aerger machen.
|
||||
const secret = randomBytes(32).toString("hex");
|
||||
|
||||
await prisma.repository.update({
|
||||
where: { id: repository.id },
|
||||
data: { webhookSecret: encryptSecret(secret), webhookLastAt: null },
|
||||
});
|
||||
|
||||
return NextResponse.json({
|
||||
secret,
|
||||
url: `${APP_URL}/api/webhooks/${repository.id}`,
|
||||
});
|
||||
}
|
||||
|
||||
export async function DELETE(_request: Request, { params }: Params) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const { id } = await params;
|
||||
const repository = await ownedRepository(id, auth.user.id);
|
||||
if (!repository) return jsonError("Repository nicht gefunden", 404);
|
||||
|
||||
await prisma.repository.update({
|
||||
where: { id: repository.id },
|
||||
data: { webhookSecret: null, webhookLastAt: null },
|
||||
});
|
||||
|
||||
return NextResponse.json({ ok: true });
|
||||
}
|
||||
@@ -0,0 +1,141 @@
|
||||
import { NextResponse } from "next/server";
|
||||
import { z } from "zod";
|
||||
import { recordActivity, shorten } from "@/lib/activity";
|
||||
import { requireUserApi } from "@/lib/auth/guard";
|
||||
import { APP_URL } from "@/lib/config";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { GitApiError, clientForConnection } from "@/lib/git";
|
||||
import { jsonError, readJsonBody } from "@/lib/security/request";
|
||||
import { formatZodError } from "@/lib/validation";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
type Params = { params: Promise<{ id: string }> };
|
||||
|
||||
const schema = z.object({
|
||||
/** Aus welchem Repository. Leer heisst: dem fuehrenden. */
|
||||
repositoryId: z.string().optional(),
|
||||
});
|
||||
|
||||
/**
|
||||
* Legt zu einer Aufgabe ein Issue im verknuepften Repository an.
|
||||
*
|
||||
* Der einzige Weg, auf dem Nebula von sich aus etwas in ein fremdes System
|
||||
* schreibt – deshalb ausdruecklich angestossen und nie nebenbei. Umgekehrt
|
||||
* gibt es die Uebernahme von Issues als Aufgaben schon laenger
|
||||
* (tasks/from-issues); die Felder sourceIssue, sourceUrl und
|
||||
* sourceRepositoryId sind dieselben, und die Eindeutigkeit je Repository
|
||||
* verhindert, dass beide Wege dasselbe doppelt anlegen.
|
||||
*/
|
||||
export async function POST(request: Request, { params }: Params) {
|
||||
const auth = await requireUserApi();
|
||||
if (!auth.ok) return auth.response;
|
||||
|
||||
const { id } = await params;
|
||||
|
||||
// Besitz haengt am Projekt – die Aufgabe selbst kennt keinen Besitzer.
|
||||
const task = await prisma.task.findFirst({
|
||||
where: { id, project: { ownerId: auth.user.id } },
|
||||
select: {
|
||||
id: true,
|
||||
title: true,
|
||||
description: true,
|
||||
projectId: true,
|
||||
sourceIssue: true,
|
||||
sourceUrl: true,
|
||||
project: { select: { name: true } },
|
||||
},
|
||||
});
|
||||
if (!task) return jsonError("Aufgabe nicht gefunden", 404);
|
||||
|
||||
// Schon verknuepft: nicht noch einmal anlegen. Ein zweites Issue zur
|
||||
// selben Aufgabe waere genau die Dublette, die from-issues vermeidet.
|
||||
if (task.sourceIssue !== null) {
|
||||
return NextResponse.json(
|
||||
{
|
||||
error: "Diese Aufgabe haengt bereits an einem Issue.",
|
||||
issue: { number: task.sourceIssue, url: task.sourceUrl },
|
||||
},
|
||||
{ status: 409 },
|
||||
);
|
||||
}
|
||||
|
||||
const body = await readJsonBody(request);
|
||||
if (!body.ok) return body.response;
|
||||
|
||||
const parsed = schema.safeParse(body.data ?? {});
|
||||
if (!parsed.success) {
|
||||
return NextResponse.json(
|
||||
{ error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
|
||||
{ status: 422 },
|
||||
);
|
||||
}
|
||||
|
||||
// Die Besitzerbedingung laeuft ueber das Projekt, dessen Besitz eben
|
||||
// geprueft wurde – eine fremde Repository-ID trifft hier also nichts.
|
||||
const repository = await prisma.repository.findFirst({
|
||||
where: {
|
||||
projectId: task.projectId,
|
||||
...(parsed.data.repositoryId ? { id: parsed.data.repositoryId } : {}),
|
||||
},
|
||||
orderBy: [{ position: "asc" }, { createdAt: "asc" }],
|
||||
include: { connection: true },
|
||||
});
|
||||
|
||||
if (!repository) {
|
||||
return jsonError("Das Projekt hat kein verknuepftes Repository.", 422);
|
||||
}
|
||||
if (!repository.connection) {
|
||||
return jsonError(
|
||||
"Das Repository haengt an keiner Git-Verbindung – ohne Token laesst sich nichts anlegen.",
|
||||
422,
|
||||
);
|
||||
}
|
||||
if (!repository.repoOwner || !repository.repoName) {
|
||||
return jsonError("Am Repository fehlen Owner oder Name.", 422);
|
||||
}
|
||||
|
||||
const client = clientForConnection(repository.connection);
|
||||
|
||||
// Rueckverweis in den Rumpf: wer das Issue im Git-System liest, soll
|
||||
// wissen, wo es herkommt und wo der Rest der Notizen liegt.
|
||||
const rumpf = [
|
||||
task.description?.trim() || null,
|
||||
`_Angelegt aus [${task.project.name}](${APP_URL}/projects/${task.projectId}) in Nebula._`,
|
||||
]
|
||||
.filter(Boolean)
|
||||
.join("\n\n");
|
||||
|
||||
try {
|
||||
const issue = await client.createIssue(
|
||||
{ owner: repository.repoOwner, name: repository.repoName },
|
||||
{ title: task.title, body: rumpf },
|
||||
);
|
||||
|
||||
const aktualisiert = await prisma.task.update({
|
||||
where: { id: task.id },
|
||||
data: {
|
||||
sourceIssue: issue.number,
|
||||
sourceUrl: issue.url,
|
||||
sourceRepositoryId: repository.id,
|
||||
},
|
||||
});
|
||||
|
||||
await recordActivity({
|
||||
projectId: task.projectId,
|
||||
userId: auth.user.id,
|
||||
kind: "TASK_ADDED",
|
||||
summary: `Issue #${issue.number} angelegt zu: ${shorten(task.title, 50)}`,
|
||||
meta: { taskId: task.id, issue: issue.number, url: issue.url },
|
||||
});
|
||||
|
||||
return NextResponse.json({ task: aktualisiert, issue }, { status: 201 });
|
||||
} catch (error) {
|
||||
// Der Aufruf ging nach draussen; die Meldung des Git-Systems ist
|
||||
// hilfreicher als ein pauschales "hat nicht geklappt".
|
||||
if (error instanceof GitApiError) {
|
||||
return jsonError(`Issue konnte nicht angelegt werden: ${error.message}`, 502);
|
||||
}
|
||||
return jsonError("Issue konnte nicht angelegt werden.", 502);
|
||||
}
|
||||
}
|
||||
@@ -10,6 +10,7 @@ import {
|
||||
refreshDerivedProgress,
|
||||
spawnRecurrence,
|
||||
} from "@/lib/tasks";
|
||||
import { issueShouldBeOpen, mirrorStatusToIssue } from "@/lib/tasks/issues";
|
||||
import { formatZodError, taskUpdateSchema } from "@/lib/validation";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
@@ -74,6 +75,23 @@ export async function PATCH(request: Request, { params }: Params) {
|
||||
|
||||
await refreshDerivedProgress(existing.projectId);
|
||||
|
||||
/**
|
||||
* Haengt die Aufgabe an einem Issue, wandert der Zustand mit: erledigt
|
||||
* schliesst es, ein Zurueckziehen oeffnet es wieder. Nur die Grenze um
|
||||
* ERLEDIGT geht nach draussen – mehr kennt ein Issue nicht.
|
||||
*
|
||||
* Fehlertolerant und ohne den Aufrufer warten zu lassen, was schiefgehen
|
||||
* kann: ein nicht erreichbares Git-System darf das Abhaken nicht
|
||||
* verhindern. Beim naechsten Wechsel wird es erneut versucht.
|
||||
*/
|
||||
if (update.status !== undefined) {
|
||||
const vorher = issueShouldBeOpen(existing.status);
|
||||
const nachher = issueShouldBeOpen(update.status as TaskStatus);
|
||||
if (vorher !== nachher) {
|
||||
await mirrorStatusToIssue(id, update.status as TaskStatus);
|
||||
}
|
||||
}
|
||||
|
||||
// Nur der Spaltenwechsel kommt in den Verlauf. Ein umbenannter Titel oder
|
||||
// ein neues Label sind zu kleinteilig, um die Geschichte des Projekts zu
|
||||
// erzaehlen – und beim Ziehen im Brett ist der Wechsel die eigentliche Tat.
|
||||
|
||||
@@ -0,0 +1,142 @@
|
||||
import { NextResponse } from "next/server";
|
||||
import { tryDecryptSecret } from "@/lib/crypto";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { rateLimit } from "@/lib/security/rateLimit";
|
||||
import { syncRepository } from "@/lib/sync";
|
||||
import { completeTaskFromIssue, statusForIssueState } from "@/lib/tasks/issues";
|
||||
import { refreshDerivedProgress } from "@/lib/tasks";
|
||||
import { parseEvent, verifySignature } from "@/lib/webhooks/verify";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
type Params = { params: Promise<{ repositoryId: string }> };
|
||||
|
||||
/** Groesse des Rumpfes deckeln – ein Push-Ereignis ist nie ein Megabyte. */
|
||||
const MAX_BODY = 512 * 1024;
|
||||
|
||||
/**
|
||||
* Eingehende Webhooks von GitHub, GitLab und Gitea.
|
||||
*
|
||||
* Der einzige Endpunkt ohne Anmeldung, der etwas schreibt. Ausgewiesen wird
|
||||
* sich mit einer Signatur ueber den Rumpf, geprueft gegen das Geheimnis, das
|
||||
* beim Einrichten am Repository hinterlegt wurde.
|
||||
*
|
||||
* Absichtlich sparsam in dem, was er tut:
|
||||
*
|
||||
* push – stoesst denselben Abgleich an wie der Zeitgeber
|
||||
* issues – geschlossen oder wieder geoeffnet wandert an die Aufgabe
|
||||
*
|
||||
* Alles andere wird angenommen und liegen gelassen. Ein Webhook, der mit
|
||||
* einem Fehler antwortet, wird von den Systemen wiederholt und irgendwann
|
||||
* abgeschaltet – deshalb ist "verstanden, nichts zu tun" die richtige
|
||||
* Antwort auf ein unbekanntes Ereignis.
|
||||
*
|
||||
* Was hier NICHT passiert: der Rumpf wird nie als Quelle fuer Inhalte
|
||||
* benutzt. Titel, Beschreibung und Zustand einer Aufgabe kommen weiter aus
|
||||
* Nebula beziehungsweise beim naechsten Abgleich aus der API. Wer das
|
||||
* Geheimnis kennt, kann also hoechstens eine Aufgabe auf- oder zumachen und
|
||||
* einen Abgleich ausloesen – nicht beliebige Daten einschleusen.
|
||||
*/
|
||||
export async function POST(request: Request, { params }: Params) {
|
||||
const { repositoryId } = await params;
|
||||
|
||||
// Die ID steht in der URL und ist damit halboeffentlich. Ein Deckel
|
||||
// dagegen, sie als Orakel zu benutzen oder den Abgleich zu verheizen.
|
||||
const limit = rateLimit(`webhook:${repositoryId}`, 60, 60_000);
|
||||
if (!limit.ok) {
|
||||
return NextResponse.json(
|
||||
{ error: "Zu viele Aufrufe." },
|
||||
{ status: 429, headers: { "Retry-After": String(limit.retryAfter) } },
|
||||
);
|
||||
}
|
||||
|
||||
const repository = await prisma.repository.findUnique({
|
||||
where: { id: repositoryId },
|
||||
include: { connection: true },
|
||||
});
|
||||
|
||||
// Unbekanntes Repository und fehlendes Geheimnis sind dieselbe Antwort:
|
||||
// ob es die ID gibt, geht den Anrufer nichts an.
|
||||
const secret = repository?.webhookSecret
|
||||
? tryDecryptSecret(repository.webhookSecret)
|
||||
: null;
|
||||
if (!repository || !secret) {
|
||||
return NextResponse.json({ error: "Unbekannt." }, { status: 404 });
|
||||
}
|
||||
|
||||
const roh = await request.text();
|
||||
if (roh.length > MAX_BODY) {
|
||||
return NextResponse.json({ error: "Rumpf zu gross." }, { status: 413 });
|
||||
}
|
||||
|
||||
/**
|
||||
* Der **rohe** Rumpf geht in die Pruefung, nicht das geparste Objekt:
|
||||
* durch JSON.parse und JSON.stringify gedreht kaeme eine andere Zeichen-
|
||||
* folge heraus und die Signatur passte nie.
|
||||
*/
|
||||
const provider = repository.connection?.provider ?? "GITEA";
|
||||
const geprueft = verifySignature(provider, secret, roh, request.headers);
|
||||
if (!geprueft.ok) {
|
||||
return NextResponse.json({ error: "Signatur ungueltig." }, { status: 401 });
|
||||
}
|
||||
|
||||
let payload: unknown = null;
|
||||
try {
|
||||
payload = JSON.parse(roh);
|
||||
} catch {
|
||||
return NextResponse.json({ error: "Kein gueltiges JSON." }, { status: 400 });
|
||||
}
|
||||
|
||||
const eventName =
|
||||
request.headers.get("x-github-event") ??
|
||||
request.headers.get("x-gitea-event") ??
|
||||
request.headers.get("x-gitlab-event");
|
||||
|
||||
const ereignis = parseEvent(provider, eventName, payload);
|
||||
|
||||
// Ab hier gilt der Aufruf als echt – das ist die Rueckmeldung darueber,
|
||||
// ob der Haken im Git-System ueberhaupt funktioniert.
|
||||
await prisma.repository.update({
|
||||
where: { id: repository.id },
|
||||
data: { webhookLastAt: new Date() },
|
||||
});
|
||||
|
||||
if (ereignis.kind === "push") {
|
||||
// Derselbe Weg wie beim Zeitgeber – nur eben sofort statt beim
|
||||
// naechsten Durchlauf.
|
||||
await syncRepository(repository.id).catch(() => undefined);
|
||||
return NextResponse.json({ ok: true, handled: "push" });
|
||||
}
|
||||
|
||||
if (ereignis.kind === "issue") {
|
||||
const task = await prisma.task.findFirst({
|
||||
where: { sourceRepositoryId: repository.id, sourceIssue: ereignis.number },
|
||||
select: { id: true, status: true, projectId: true },
|
||||
});
|
||||
if (!task) {
|
||||
return NextResponse.json({ ok: true, handled: "issue", matched: false });
|
||||
}
|
||||
|
||||
const ziel = statusForIssueState(ereignis.open, task.status);
|
||||
|
||||
if (ziel === "DONE" && task.status !== "DONE") {
|
||||
// Ueber die gemeinsame Funktion, damit ein geschlossenes Issue
|
||||
// dasselbe bewirkt wie ein Haken in der Oberflaeche: naechste Fassung
|
||||
// einer wiederkehrenden Aufgabe und ein Eintrag im Verlauf.
|
||||
await completeTaskFromIssue(task.id, "webhook");
|
||||
} else if (ziel !== task.status) {
|
||||
// Wieder geoeffnet. Das darf nur der Webhook, weil hier ein echtes
|
||||
// "reopened" vorliegt – der Abgleich sieht nur Zustaende und wuerde
|
||||
// sonst eine bewusst erledigte Aufgabe aufmachen.
|
||||
await prisma.task.update({
|
||||
where: { id: task.id },
|
||||
data: { status: ziel, doneAt: null },
|
||||
});
|
||||
await refreshDerivedProgress(task.projectId);
|
||||
}
|
||||
|
||||
return NextResponse.json({ ok: true, handled: "issue", matched: true, status: ziel });
|
||||
}
|
||||
|
||||
return NextResponse.json({ ok: true, handled: "ignored", event: ereignis.name });
|
||||
}
|
||||
@@ -11,7 +11,7 @@ import { TaskBoard } from "@/components/tasks/TaskBoard";
|
||||
import { requireUserPage } from "@/lib/auth/guard";
|
||||
import { getSessionUser } from "@/lib/auth/session";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { connectionSafeSelect, projectDetailInclude } from "@/lib/projects";
|
||||
import { connectionSafeSelect, projectDetailInclude, webhookRepositoryIds } from "@/lib/projects";
|
||||
import type { ConnectionSafe, ProjectDetail } from "@/types";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
@@ -55,6 +55,9 @@ export default async function ProjectPage({ params }: PageProps) {
|
||||
|
||||
const detail = project as unknown as ProjectDetail;
|
||||
|
||||
// Nur die Angabe "hier haengt ein Webhook", nicht das Geheimnis selbst.
|
||||
const webhookIds = await webhookRepositoryIds(detail.id);
|
||||
|
||||
const fuehrend = detail.repositories[0]?.snapshot;
|
||||
const readme = fuehrend?.readme
|
||||
? {
|
||||
@@ -82,8 +85,16 @@ export default async function ProjectPage({ params }: PageProps) {
|
||||
progressFromTasks={detail.progressFromTasks}
|
||||
/>
|
||||
|
||||
{/*
|
||||
min-w-0 an beiden Spalten ist hier nicht Kosmetik, sondern der Kern:
|
||||
ein Rasterkind hat "min-width: auto" und weigert sich damit, unter
|
||||
die Inhaltsbreite seines breitesten Kindes zu schrumpfen. Die
|
||||
Heatmap ist ueber 700px breit – auf dem Telefon zog sie damit die
|
||||
ganze Spalte und mit ihr die Seite auseinander. Erst mit min-w-0
|
||||
greift das overflow-x-auto darin ueberhaupt.
|
||||
*/}
|
||||
<div className="grid gap-6 lg:grid-cols-12">
|
||||
<div className="space-y-6 lg:col-span-5">
|
||||
<div className="min-w-0 space-y-6 lg:col-span-5">
|
||||
<section className="glass p-5">
|
||||
<h2 className="flex items-center gap-2 text-sm font-semibold uppercase tracking-wider text-slate-300">
|
||||
<FileText className="h-4 w-4 text-cyan-300" />
|
||||
@@ -112,10 +123,11 @@ export default async function ProjectPage({ params }: PageProps) {
|
||||
<NotesPanel projectId={detail.id} notes={detail.notes} />
|
||||
</div>
|
||||
|
||||
<div className="space-y-6 lg:col-span-7">
|
||||
<div className="min-w-0 space-y-6 lg:col-span-7">
|
||||
<GitPanel
|
||||
project={detail}
|
||||
connections={connections as unknown as ConnectionSafe[]}
|
||||
webhookRepoIds={webhookIds}
|
||||
/>
|
||||
<ActivityFeed projectId={detail.id} initial={detail.activities} />
|
||||
</div>
|
||||
|
||||
@@ -42,6 +42,7 @@ export default async function TasksPage() {
|
||||
dueDate: task.dueDate ? task.dueDate.toISOString() : null,
|
||||
labels: task.labels,
|
||||
recurrence: task.recurrence,
|
||||
sourceIssue: task.sourceIssue,
|
||||
sourceUrl: task.sourceUrl,
|
||||
bucket: dueBucket(task.dueDate, jetzt),
|
||||
project: task.project,
|
||||
|
||||
@@ -17,6 +17,7 @@ import {
|
||||
Lock,
|
||||
Package,
|
||||
Plus,
|
||||
Radio,
|
||||
RefreshCw,
|
||||
ShieldCheck,
|
||||
Star,
|
||||
@@ -26,6 +27,7 @@ import {
|
||||
import { CiBadge } from "@/components/CiBadge";
|
||||
import { Heatmap } from "@/components/Heatmap";
|
||||
import { RepositoryDialog } from "@/components/RepositoryDialog";
|
||||
import { WebhookDialog } from "@/components/WebhookDialog";
|
||||
import { Sparkline } from "@/components/Sparkline";
|
||||
import { repoTitle } from "@/lib/git/meta";
|
||||
import { asArray, asCalendar, asRecord } from "@/types";
|
||||
@@ -55,9 +57,13 @@ type TabKey = (typeof TABS)[number]["key"];
|
||||
export function GitPanel({
|
||||
project,
|
||||
connections,
|
||||
webhookRepoIds = [],
|
||||
}: {
|
||||
project: ProjectDetail;
|
||||
connections: ConnectionSafe[];
|
||||
/** Repositories mit hinterlegtem Webhook. Das Geheimnis selbst bleibt
|
||||
auf dem Server – hier kommt nur an, ob eines existiert. */
|
||||
webhookRepoIds?: string[];
|
||||
}) {
|
||||
const router = useRouter();
|
||||
const [tab, setTab] = useState<TabKey>("pulls");
|
||||
@@ -65,6 +71,7 @@ export function GitPanel({
|
||||
const [importing, setImporting] = useState(false);
|
||||
const [message, setMessage] = useState<{ ok: boolean; text: string } | null>(null);
|
||||
const [addOpen, setAddOpen] = useState(false);
|
||||
const [webhookOpen, setWebhookOpen] = useState(false);
|
||||
|
||||
const repositories = project.repositories;
|
||||
const [selectedId, setSelectedId] = useState<string | null>(repositories[0]?.id ?? null);
|
||||
@@ -72,6 +79,7 @@ export function GitPanel({
|
||||
// Nach dem Entfernen zeigt die Auswahl ins Leere – dann auf das fuehrende
|
||||
// zurueckfallen, statt eine leere Ansicht zu zeigen.
|
||||
const repository = repositories.find((entry) => entry.id === selectedId) ?? repositories[0] ?? null;
|
||||
const webhookAktiv = repository ? webhookRepoIds.includes(repository.id) : false;
|
||||
|
||||
/** Offene Issues als Aufgaben anlegen – ohne erneuten Abruf beim Provider. */
|
||||
async function importIssues() {
|
||||
@@ -280,6 +288,24 @@ export function GitPanel({
|
||||
Repository
|
||||
</button>
|
||||
)}
|
||||
<button
|
||||
type="button"
|
||||
onClick={() => setWebhookOpen(true)}
|
||||
className={cn(
|
||||
"rounded-lg p-2 transition-colors",
|
||||
webhookAktiv
|
||||
? "text-emerald-300 hover:bg-emerald-500/10"
|
||||
: "text-slate-500 hover:bg-white/8 hover:text-violet-300",
|
||||
)}
|
||||
aria-label="Webhook einrichten"
|
||||
title={
|
||||
webhookAktiv
|
||||
? "Webhook ist eingerichtet – meldet Aenderungen sofort"
|
||||
: "Webhook einrichten – Aenderungen sofort statt beim naechsten Abgleich"
|
||||
}
|
||||
>
|
||||
<Radio className="h-4 w-4" />
|
||||
</button>
|
||||
<button
|
||||
type="button"
|
||||
onClick={() => removeRepository(repository)}
|
||||
@@ -312,6 +338,16 @@ export function GitPanel({
|
||||
connections={connections}
|
||||
/>
|
||||
|
||||
<WebhookDialog
|
||||
open={webhookOpen}
|
||||
onClose={() => setWebhookOpen(false)}
|
||||
repositoryId={repository.id}
|
||||
repositoryTitle={repoTitle(repository)}
|
||||
provider={repository.connection?.provider ?? null}
|
||||
eingerichtet={webhookAktiv}
|
||||
zuletzt={repository.webhookLastAt}
|
||||
/>
|
||||
|
||||
{message ? (
|
||||
<p
|
||||
className={cn(
|
||||
|
||||
@@ -0,0 +1,244 @@
|
||||
"use client";
|
||||
|
||||
import { useState } from "react";
|
||||
import { useRouter } from "next/navigation";
|
||||
import { Check, Copy, Loader2, Radio, Trash2 } from "lucide-react";
|
||||
import type { GitProvider } from "@prisma/client";
|
||||
import { Modal } from "@/components/ui/Modal";
|
||||
import { formatRelative } from "@/lib/utils";
|
||||
|
||||
/**
|
||||
* Einrichtung des Webhooks fuer ein Repository.
|
||||
*
|
||||
* Der Haken wird im Git-System von Hand eingetragen. Ihn ueber die API
|
||||
* anzulegen waere machbar, verlangte aber Administrationsrechte am
|
||||
* Repository – deutlich mehr, als Nebula sonst braucht, und es waere ein
|
||||
* Recht, das die meisten Token gar nicht haben.
|
||||
*
|
||||
* Das Geheimnis ist genau einmal zu sehen: danach liegt nur noch die
|
||||
* verschluesselte Fassung in der Datenbank, wie bei den Zugangstoken.
|
||||
*/
|
||||
|
||||
/** Wo der Haken im jeweiligen System einzutragen ist. */
|
||||
const ANLEITUNG: Record<GitProvider, { pfad: string; ereignisse: string }> = {
|
||||
GITHUB: {
|
||||
pfad: "Settings → Webhooks → Add webhook",
|
||||
ereignisse: "Content type „application/json“, Events: Pushes und Issues",
|
||||
},
|
||||
GITEA: {
|
||||
pfad: "Einstellungen → Webhooks → Gitea",
|
||||
ereignisse: "Auslöser: Push und Issues",
|
||||
},
|
||||
GITLAB: {
|
||||
pfad: "Settings → Webhooks",
|
||||
ereignisse: "Trigger: Push events und Issues events",
|
||||
},
|
||||
};
|
||||
|
||||
export function WebhookDialog({
|
||||
open,
|
||||
onClose,
|
||||
repositoryId,
|
||||
repositoryTitle,
|
||||
provider,
|
||||
eingerichtet,
|
||||
zuletzt,
|
||||
}: {
|
||||
open: boolean;
|
||||
onClose: () => void;
|
||||
repositoryId: string;
|
||||
repositoryTitle: string;
|
||||
provider: GitProvider | null;
|
||||
eingerichtet: boolean;
|
||||
zuletzt: Date | string | null;
|
||||
}) {
|
||||
const router = useRouter();
|
||||
const [busy, setBusy] = useState(false);
|
||||
const [fehler, setFehler] = useState<string | null>(null);
|
||||
const [geheimnis, setGeheimnis] = useState<string | null>(null);
|
||||
const [url, setUrl] = useState<string | null>(null);
|
||||
const [kopiert, setKopiert] = useState<string | null>(null);
|
||||
|
||||
// Ohne Verbindung ist das System unbekannt. Dann lieber allgemein bleiben,
|
||||
// als eine Anleitung fuer das falsche zu zeigen.
|
||||
const anleitung = provider ? ANLEITUNG[provider] : null;
|
||||
|
||||
async function erzeugen() {
|
||||
setBusy(true);
|
||||
setFehler(null);
|
||||
try {
|
||||
const antwort = await fetch(`/api/repositories/${repositoryId}/webhook`, {
|
||||
method: "POST",
|
||||
headers: { "Content-Type": "application/json" },
|
||||
body: JSON.stringify({}),
|
||||
});
|
||||
const nutzlast = await antwort.json().catch(() => ({}));
|
||||
if (!antwort.ok) throw new Error(nutzlast.error ?? "Fehlgeschlagen.");
|
||||
setGeheimnis(nutzlast.secret);
|
||||
setUrl(nutzlast.url);
|
||||
router.refresh();
|
||||
} catch (gefangen) {
|
||||
setFehler(gefangen instanceof Error ? gefangen.message : String(gefangen));
|
||||
} finally {
|
||||
setBusy(false);
|
||||
}
|
||||
}
|
||||
|
||||
async function zuruecknehmen() {
|
||||
if (!window.confirm("Webhook zuruecknehmen? Eingehende Aufrufe werden dann abgewiesen.")) {
|
||||
return;
|
||||
}
|
||||
setBusy(true);
|
||||
try {
|
||||
await fetch(`/api/repositories/${repositoryId}/webhook`, { method: "DELETE" });
|
||||
setGeheimnis(null);
|
||||
setUrl(null);
|
||||
router.refresh();
|
||||
onClose();
|
||||
} finally {
|
||||
setBusy(false);
|
||||
}
|
||||
}
|
||||
|
||||
async function kopieren(wert: string, was: string) {
|
||||
try {
|
||||
await navigator.clipboard.writeText(wert);
|
||||
setKopiert(was);
|
||||
setTimeout(() => setKopiert(null), 2000);
|
||||
} catch {
|
||||
// Ohne Zwischenablage bleibt der Text zum Markieren stehen.
|
||||
}
|
||||
}
|
||||
|
||||
return (
|
||||
<Modal
|
||||
open={open}
|
||||
onClose={onClose}
|
||||
width="md"
|
||||
title="Webhook einrichten"
|
||||
description={`Damit meldet ${repositoryTitle} Aenderungen sofort, statt auf den naechsten Abgleich zu warten.`}
|
||||
>
|
||||
<div className="space-y-4">
|
||||
{eingerichtet && !geheimnis ? (
|
||||
<div className="rounded-lg border border-emerald-500/25 bg-emerald-500/8 px-3 py-2.5">
|
||||
<p className="flex items-center gap-2 text-sm text-emerald-100">
|
||||
<Radio className="h-4 w-4 shrink-0" />
|
||||
Webhook ist eingerichtet.
|
||||
</p>
|
||||
<p className="mt-1 text-xs text-emerald-300/70" suppressHydrationWarning>
|
||||
{zuletzt
|
||||
? `Zuletzt empfangen ${formatRelative(zuletzt)}.`
|
||||
: "Bisher ist noch kein Aufruf angekommen — der Haken im Git-System fehlt vermutlich noch."}
|
||||
</p>
|
||||
</div>
|
||||
) : null}
|
||||
|
||||
{geheimnis && url ? (
|
||||
<div className="space-y-3">
|
||||
<Feld label="URL" wert={url} kopiert={kopiert === "url"} onCopy={() => kopieren(url, "url")} />
|
||||
<Feld
|
||||
label="Geheimnis (Secret)"
|
||||
wert={geheimnis}
|
||||
kopiert={kopiert === "secret"}
|
||||
onCopy={() => kopieren(geheimnis, "secret")}
|
||||
/>
|
||||
<p className="rounded-lg border border-amber-500/25 bg-amber-500/8 px-3 py-2 text-xs text-amber-200">
|
||||
Das Geheimnis ist <strong>jetzt zum einzigen Mal</strong> zu sehen. Danach liegt es
|
||||
nur noch verschluesselt in der Datenbank. Verloren? Dann hier ein neues erzeugen —
|
||||
das alte gilt dann nicht mehr.
|
||||
</p>
|
||||
</div>
|
||||
) : null}
|
||||
|
||||
<div className="rounded-lg border border-white/8 bg-white/2 px-3 py-2.5 text-xs text-slate-400">
|
||||
<p className="font-semibold text-slate-300">Im Git-System eintragen</p>
|
||||
{anleitung ? (
|
||||
<>
|
||||
<p className="mt-1">{anleitung.pfad}</p>
|
||||
<p className="mt-0.5">{anleitung.ereignisse}</p>
|
||||
</>
|
||||
) : (
|
||||
<p className="mt-1">
|
||||
In den Einstellungen des Repositories unter „Webhooks“, mit den Ausloesern
|
||||
Push und Issues. Ist eine Git-Verbindung hinterlegt, steht hier der genaue
|
||||
Pfad fuer das jeweilige System.
|
||||
</p>
|
||||
)}
|
||||
<p className="mt-2 text-slate-500">
|
||||
Nebula wertet nur Push und Issues aus. Alles andere wird angenommen und liegen
|
||||
gelassen — ein Fehler wuerde das Git-System sonst zum Wiederholen bringen.
|
||||
</p>
|
||||
</div>
|
||||
|
||||
{fehler ? (
|
||||
<p className="rounded-lg border border-rose-500/30 bg-rose-500/10 px-3 py-2 text-sm text-rose-200">
|
||||
{fehler}
|
||||
</p>
|
||||
) : null}
|
||||
|
||||
<div className="flex flex-wrap items-center justify-between gap-2 pt-1">
|
||||
{eingerichtet ? (
|
||||
<button
|
||||
type="button"
|
||||
className="btn btn-danger px-3 py-1.5 text-xs"
|
||||
onClick={zuruecknehmen}
|
||||
disabled={busy}
|
||||
>
|
||||
<Trash2 className="h-3.5 w-3.5" />
|
||||
Zuruecknehmen
|
||||
</button>
|
||||
) : (
|
||||
<span />
|
||||
)}
|
||||
|
||||
<div className="flex gap-2">
|
||||
<button type="button" className="btn btn-ghost" onClick={onClose} disabled={busy}>
|
||||
{geheimnis ? "Fertig" : "Schliessen"}
|
||||
</button>
|
||||
<button type="button" className="btn btn-primary" onClick={erzeugen} disabled={busy}>
|
||||
{busy ? <Loader2 className="h-4 w-4 animate-spin" /> : <Radio className="h-4 w-4" />}
|
||||
{eingerichtet ? "Neues Geheimnis" : "Einrichten"}
|
||||
</button>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
</Modal>
|
||||
);
|
||||
}
|
||||
|
||||
function Feld({
|
||||
label,
|
||||
wert,
|
||||
kopiert,
|
||||
onCopy,
|
||||
}: {
|
||||
label: string;
|
||||
wert: string;
|
||||
kopiert: boolean;
|
||||
onCopy: () => void;
|
||||
}) {
|
||||
return (
|
||||
<div>
|
||||
<span className="field-label">{label}</span>
|
||||
<div className="flex items-center gap-2">
|
||||
{/* tabIndex: der Kasten scrollt seitlich und muss deshalb auch mit
|
||||
der Tastatur erreichbar sein – sonst kommt man an das Ende einer
|
||||
langen URL nur mit der Maus. */}
|
||||
<code
|
||||
tabIndex={0}
|
||||
className="min-w-0 flex-1 overflow-x-auto rounded-lg border border-white/9 bg-[rgba(8,10,24,0.6)] px-3 py-2 font-mono text-xs text-slate-200"
|
||||
>
|
||||
{wert}
|
||||
</code>
|
||||
<button
|
||||
type="button"
|
||||
onClick={onCopy}
|
||||
className="btn btn-ghost shrink-0 px-2.5 py-2"
|
||||
aria-label={`${label} kopieren`}
|
||||
>
|
||||
{kopiert ? <Check className="h-4 w-4 text-emerald-300" /> : <Copy className="h-4 w-4" />}
|
||||
</button>
|
||||
</div>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
@@ -2,12 +2,33 @@
|
||||
|
||||
import { useEffect, useState } from "react";
|
||||
import { useRouter } from "next/navigation";
|
||||
import { Loader2, Trash2 } from "lucide-react";
|
||||
import type { Recurrence, Task, TaskStatus } from "@prisma/client";
|
||||
import { ExternalLink, GitPullRequestArrow, Loader2, Trash2 } from "lucide-react";
|
||||
import type { Recurrence, TaskStatus } from "@prisma/client";
|
||||
import { Modal } from "@/components/ui/Modal";
|
||||
import { RECURRENCE_META, TASK_STATUS_META, TASK_STATUS_ORDER } from "@/lib/tasks";
|
||||
import { cn, parseTags } from "@/lib/utils";
|
||||
|
||||
/**
|
||||
* Was der Dialog von einer Aufgabe tatsaechlich liest.
|
||||
*
|
||||
* Bewusst nicht der vollstaendige Prisma-Datensatz: die Aufgabenuebersicht
|
||||
* ueber alle Projekte reicht eine schlankere Fassung durch, in der das Datum
|
||||
* als Zeichenkette ankommt – ein Date ueberlebt den Weg vom Server zum
|
||||
* Browser nicht. Ein echtes Task erfuellt diese Form ebenfalls.
|
||||
*/
|
||||
export interface EditableTask {
|
||||
id: string;
|
||||
title: string;
|
||||
description: string | null;
|
||||
status: TaskStatus;
|
||||
dueDate: Date | string | null;
|
||||
labels: string[];
|
||||
recurrence: Recurrence | null;
|
||||
/** Gesetzt, sobald die Aufgabe an einem Git-Issue haengt. */
|
||||
sourceIssue?: number | null;
|
||||
sourceUrl?: string | null;
|
||||
}
|
||||
|
||||
/** Datum fuer <input type="date"> – ortszeitbezogen, nicht UTC. */
|
||||
function toDateInput(value: Date | string | null): string {
|
||||
if (!value) return "";
|
||||
@@ -26,7 +47,7 @@ export function TaskDialog({
|
||||
}: {
|
||||
open: boolean;
|
||||
projectId: string;
|
||||
task: Task | null;
|
||||
task: EditableTask | null;
|
||||
initialStatus: TaskStatus;
|
||||
onClose: () => void;
|
||||
}) {
|
||||
@@ -38,10 +59,38 @@ export function TaskDialog({
|
||||
const [labels, setLabels] = useState("");
|
||||
const [recurrence, setRecurrence] = useState<string>("");
|
||||
const [busy, setBusy] = useState(false);
|
||||
const [issueBusy, setIssueBusy] = useState(false);
|
||||
const [error, setError] = useState<string | null>(null);
|
||||
|
||||
const isEdit = Boolean(task);
|
||||
|
||||
/**
|
||||
* Legt zur Aufgabe ein Issue im verknuepften Repository an.
|
||||
*
|
||||
* Ausdruecklich per Knopf und nicht beim Speichern: was in ein fremdes
|
||||
* System geschrieben wird, soll jemand gewollt haben.
|
||||
*/
|
||||
async function createIssue() {
|
||||
if (!task) return;
|
||||
setIssueBusy(true);
|
||||
setError(null);
|
||||
try {
|
||||
const response = await fetch(`/api/tasks/${task.id}/issue`, {
|
||||
method: "POST",
|
||||
headers: { "Content-Type": "application/json" },
|
||||
body: JSON.stringify({}),
|
||||
});
|
||||
const payload = await response.json().catch(() => ({}));
|
||||
if (!response.ok) throw new Error(payload.error ?? "Issue konnte nicht angelegt werden.");
|
||||
onClose();
|
||||
router.refresh();
|
||||
} catch (caught) {
|
||||
setError(caught instanceof Error ? caught.message : String(caught));
|
||||
} finally {
|
||||
setIssueBusy(false);
|
||||
}
|
||||
}
|
||||
|
||||
useEffect(() => {
|
||||
if (!open) return;
|
||||
setTitle(task?.title ?? "");
|
||||
@@ -231,6 +280,54 @@ export function TaskDialog({
|
||||
</p>
|
||||
) : null}
|
||||
|
||||
{/* Verknuepfung mit einem Git-Issue. Nur beim Bearbeiten – zu einer
|
||||
Aufgabe, die es noch nicht gibt, laesst sich keins anlegen. */}
|
||||
{isEdit ? (
|
||||
<div className="rounded-lg border border-white/8 bg-white/2 px-3 py-2.5">
|
||||
{task?.sourceUrl || task?.sourceIssue ? (
|
||||
<p className="flex flex-wrap items-center gap-x-2 gap-y-1 text-xs text-slate-400">
|
||||
<GitPullRequestArrow className="h-3.5 w-3.5 shrink-0 text-violet-300" />
|
||||
Verknuepft mit
|
||||
{task.sourceUrl ? (
|
||||
<a
|
||||
href={task.sourceUrl}
|
||||
target="_blank"
|
||||
rel="noopener noreferrer"
|
||||
className="inline-flex items-center gap-1 text-violet-300 underline-offset-2 hover:underline"
|
||||
>
|
||||
Issue #{task.sourceIssue}
|
||||
<ExternalLink className="h-3 w-3" />
|
||||
</a>
|
||||
) : (
|
||||
<span className="text-slate-300">Issue #{task.sourceIssue}</span>
|
||||
)}
|
||||
<span className="w-full text-[11px] text-slate-500">
|
||||
Erledigt schliesst das Issue, ein Zurueckziehen oeffnet es wieder.
|
||||
</span>
|
||||
</p>
|
||||
) : (
|
||||
<div className="flex flex-wrap items-center justify-between gap-2">
|
||||
<span className="text-xs text-slate-500">
|
||||
Noch nicht mit einem Issue verknuepft.
|
||||
</span>
|
||||
<button
|
||||
type="button"
|
||||
className="btn btn-ghost px-2.5 py-1.5 text-xs"
|
||||
onClick={createIssue}
|
||||
disabled={busy || issueBusy}
|
||||
>
|
||||
{issueBusy ? (
|
||||
<Loader2 className="h-3.5 w-3.5 animate-spin" />
|
||||
) : (
|
||||
<GitPullRequestArrow className="h-3.5 w-3.5" />
|
||||
)}
|
||||
Als Issue anlegen
|
||||
</button>
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
) : null}
|
||||
|
||||
<div className="flex items-center justify-between gap-2 pt-1">
|
||||
{isEdit ? (
|
||||
<button
|
||||
|
||||
@@ -14,6 +14,7 @@ import {
|
||||
} from "lucide-react";
|
||||
import type { TaskStatus } from "@prisma/client";
|
||||
import { QuickCapture } from "@/components/QuickCapture";
|
||||
import { TaskDialog } from "@/components/tasks/TaskDialog";
|
||||
import {
|
||||
DUE_BUCKET_META,
|
||||
DUE_BUCKET_ORDER,
|
||||
@@ -44,6 +45,8 @@ export function TaskOverview({ tasks }: { tasks: TaskOverviewItem[] }) {
|
||||
const [zeigeErledigte, setZeigeErledigte] = useState(false);
|
||||
const [erfassenOffen, setErfassenOffen] = useState(false);
|
||||
const [laufend, setLaufend] = useState<Set<string>>(new Set());
|
||||
/** Welche Aufgabe gerade im Dialog liegt. null heisst: keiner offen. */
|
||||
const [bearbeiten, setBearbeiten] = useState<TaskOverviewItem | null>(null);
|
||||
|
||||
const projekte = useMemo(() => {
|
||||
const map = new Map<string, string>();
|
||||
@@ -253,6 +256,7 @@ export function TaskOverview({ tasks }: { tasks: TaskOverviewItem[] }) {
|
||||
task={task}
|
||||
busy={laufend.has(task.id)}
|
||||
onToggle={() => abhaken(task)}
|
||||
onEdit={() => setBearbeiten(task)}
|
||||
/>
|
||||
))}
|
||||
</ul>
|
||||
@@ -267,6 +271,18 @@ export function TaskOverview({ tasks }: { tasks: TaskOverviewItem[] }) {
|
||||
onClose={() => setErfassenOffen(false)}
|
||||
initialMode="aufgabe"
|
||||
/>
|
||||
|
||||
{/* Derselbe Dialog wie im Projektbrett – er kennt seine Aufgabe ueber
|
||||
die ID und braucht das Projekt nur zum Anlegen. */}
|
||||
{bearbeiten ? (
|
||||
<TaskDialog
|
||||
open
|
||||
projectId={bearbeiten.project.id}
|
||||
task={bearbeiten}
|
||||
initialStatus={bearbeiten.status}
|
||||
onClose={() => setBearbeiten(null)}
|
||||
/>
|
||||
) : null}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
@@ -275,10 +291,12 @@ function TaskRow({
|
||||
task,
|
||||
busy,
|
||||
onToggle,
|
||||
onEdit,
|
||||
}: {
|
||||
task: TaskOverviewItem;
|
||||
busy: boolean;
|
||||
onToggle: () => void;
|
||||
onEdit: () => void;
|
||||
}) {
|
||||
const meta = TASK_STATUS_META[task.status];
|
||||
const erledigt = task.status === "DONE";
|
||||
@@ -303,14 +321,21 @@ function TaskRow({
|
||||
|
||||
<div className="min-w-0 flex-1">
|
||||
<div className="flex items-center gap-1.5">
|
||||
<span
|
||||
{/* Der Titel oeffnet den Bearbeiten-Dialog. Frueher fuehrte von
|
||||
hier nur der Weg ins Projekt – wer eine Faelligkeit aendern
|
||||
wollte, musste erst dorthin springen und die Aufgabe im Brett
|
||||
wiederfinden. */}
|
||||
<button
|
||||
type="button"
|
||||
onClick={onEdit}
|
||||
className={cn(
|
||||
"truncate text-sm",
|
||||
"truncate text-left text-sm transition-colors hover:text-violet-200",
|
||||
erledigt ? "text-slate-500 line-through" : "text-slate-100",
|
||||
)}
|
||||
title="Aufgabe bearbeiten"
|
||||
>
|
||||
{task.title}
|
||||
</span>
|
||||
</button>
|
||||
{task.recurrence ? (
|
||||
<Repeat
|
||||
className="h-3 w-3 shrink-0 text-slate-500"
|
||||
|
||||
@@ -33,9 +33,45 @@ export function Modal({
|
||||
width = "lg",
|
||||
}: ModalProps) {
|
||||
const [mounted, setMounted] = useState(false);
|
||||
const [sichtfenster, setSichtfenster] = useState<{ height: number; top: number } | null>(null);
|
||||
|
||||
useEffect(() => setMounted(true), []);
|
||||
|
||||
/**
|
||||
* Der Dialog richtet sich nach dem *sichtbaren* Fenster, nicht nach dem
|
||||
* Layoutfenster.
|
||||
*
|
||||
* Auf dem Telefon schiebt sich die Tastatur ueber die untere Haelfte,
|
||||
* ohne dass sich daran etwas fuer die Seite aendert: "position: fixed"
|
||||
* und "100vh" beziehen sich weiter auf das volle Fenster. Ein zentrierter
|
||||
* Dialog liegt damit zur Haelfte unter der Tastatur – genau dort, wo das
|
||||
* Eingabefeld ist.
|
||||
*
|
||||
* Die VisualViewport-API meldet, was wirklich zu sehen ist. Hoehe und
|
||||
* oberer Rand daraus zu setzen rueckt den Dialog in den freien Bereich,
|
||||
* und weil der Behaelter scrollbar ist, holt der Browser das fokussierte
|
||||
* Feld von selbst ins Bild.
|
||||
*/
|
||||
useEffect(() => {
|
||||
if (!open) return;
|
||||
const fenster = window.visualViewport;
|
||||
if (!fenster) return;
|
||||
|
||||
const nachfuehren = () => {
|
||||
setSichtfenster({ height: fenster.height, top: fenster.offsetTop });
|
||||
};
|
||||
nachfuehren();
|
||||
|
||||
fenster.addEventListener("resize", nachfuehren);
|
||||
// Beim Scrollen mit offener Tastatur wandert der sichtbare Ausschnitt.
|
||||
fenster.addEventListener("scroll", nachfuehren);
|
||||
return () => {
|
||||
fenster.removeEventListener("resize", nachfuehren);
|
||||
fenster.removeEventListener("scroll", nachfuehren);
|
||||
setSichtfenster(null);
|
||||
};
|
||||
}, [open]);
|
||||
|
||||
useEffect(() => {
|
||||
if (!open) return;
|
||||
const onKey = (event: KeyboardEvent) => {
|
||||
@@ -53,7 +89,14 @@ export function Modal({
|
||||
if (!mounted || !open) return null;
|
||||
|
||||
return createPortal(
|
||||
<div className="fixed inset-0 z-[120] flex items-start justify-center overflow-y-auto p-3 sm:p-8">
|
||||
<div
|
||||
className="fixed inset-x-0 z-[120] flex items-start justify-center overflow-y-auto p-3 sm:p-8"
|
||||
style={
|
||||
sichtfenster
|
||||
? { top: sichtfenster.top, height: sichtfenster.height }
|
||||
: { top: 0, bottom: 0 }
|
||||
}
|
||||
>
|
||||
<button
|
||||
type="button"
|
||||
aria-label="Dialog schliessen"
|
||||
|
||||
+2
-2
@@ -46,7 +46,7 @@ export function setMfaCookie(response: NextResponse, token: string) {
|
||||
name: MFA_COOKIE,
|
||||
value: token,
|
||||
httpOnly: true,
|
||||
sameSite: "lax",
|
||||
sameSite: "strict",
|
||||
secure: COOKIES_SECURE,
|
||||
path: "/",
|
||||
maxAge: Math.floor(MFA_TTL_MS / 1000),
|
||||
@@ -58,7 +58,7 @@ export function clearMfaCookie(response: NextResponse) {
|
||||
name: MFA_COOKIE,
|
||||
value: "",
|
||||
httpOnly: true,
|
||||
sameSite: "lax",
|
||||
sameSite: "strict",
|
||||
secure: COOKIES_SECURE,
|
||||
path: "/",
|
||||
maxAge: 0,
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
import { describe, expect, it } from "vitest";
|
||||
import { PASSWORD_MIN_LENGTH } from "./constants";
|
||||
import { hashPassword, validatePasswordStrength, verifyPassword } from "./password";
|
||||
import { hashPassword, needsRehash, validatePasswordStrength, verifyPassword } from "./password";
|
||||
|
||||
describe("hashPassword und verifyPassword", () => {
|
||||
it("erkennt das richtige Passwort wieder", async () => {
|
||||
@@ -64,3 +64,82 @@ describe("validatePasswordStrength", () => {
|
||||
expect(validatePasswordStrength("a".repeat(300))).toMatch(/hoechstens/);
|
||||
});
|
||||
});
|
||||
|
||||
describe("Aufwand nach OWASP", () => {
|
||||
it("hasht mit den heute vorgesehenen Parametern", async () => {
|
||||
// OWASP Password Storage Cheat Sheet: N = 2^17, r = 8, p = 1.
|
||||
const hash = await hashPassword("ein-langes-testpasswort");
|
||||
const [, N, r, p] = hash.split("$");
|
||||
expect(Number(N)).toBe(131072);
|
||||
expect(Number(r)).toBe(8);
|
||||
expect(Number(p)).toBe(1);
|
||||
});
|
||||
|
||||
it("prueft alte Hashes weiterhin, weil die Parameter im Hash stehen", async () => {
|
||||
// Von Hand mit den frueheren Werten erzeugt – muss gueltig bleiben,
|
||||
// sonst waere ein Anheben des Aufwands eine Aussperrung.
|
||||
const alt =
|
||||
"scrypt$32768$8$1$" +
|
||||
Buffer.from("salzsalzsalzsalz").toString("base64url") +
|
||||
"$";
|
||||
// Echten Hash mit alten Parametern bauen:
|
||||
const { scrypt } = await import("node:crypto");
|
||||
const { promisify } = await import("node:util");
|
||||
const s = promisify(scrypt) as (a: string, b: Buffer, c: number, d: object) => Promise<Buffer>;
|
||||
const salt = Buffer.from("salzsalzsalzsalz");
|
||||
const derived = await s("ein-langes-testpasswort", salt, 64, {
|
||||
N: 32768,
|
||||
r: 8,
|
||||
p: 1,
|
||||
maxmem: 96 * 1024 * 1024,
|
||||
});
|
||||
const alterHash = `scrypt$32768$8$1$${salt.toString("base64url")}$${derived.toString("base64url")}`;
|
||||
expect(alt.length).toBeGreaterThan(0);
|
||||
|
||||
await expect(verifyPassword("ein-langes-testpasswort", alterHash)).resolves.toBe(true);
|
||||
// ... und wird als erneuerungsbeduerftig erkannt.
|
||||
expect(needsRehash(alterHash)).toBe(true);
|
||||
});
|
||||
|
||||
it("laesst frische Hashes in Ruhe", async () => {
|
||||
expect(needsRehash(await hashPassword("ein-langes-testpasswort"))).toBe(false);
|
||||
});
|
||||
|
||||
it("erkennt gleichwertige Kombinationen als ausreichend", () => {
|
||||
// N=2^16 mit p=2 ergibt denselben Gesamtaufwand wie N=2^17 mit p=1 und
|
||||
// ist nach OWASP ebenso zulaessig.
|
||||
expect(needsRehash("scrypt$65536$8$2$c2FsdA$aGFzaA")).toBe(false);
|
||||
// N=2^15 mit p=1 dagegen nicht – das war der alte Zustand.
|
||||
expect(needsRehash("scrypt$32768$8$1$c2FsdA$aGFzaA")).toBe(true);
|
||||
});
|
||||
|
||||
it("haelt Unsinn fuer erneuerungsbeduerftig", () => {
|
||||
expect(needsRehash("voelliger-unsinn")).toBe(true);
|
||||
expect(needsRehash(null)).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe("Schwache Muster", () => {
|
||||
it("weist Wiederholungen ab", () => {
|
||||
expect(validatePasswordStrength("aaaaaaaaaaaa")).toBeTruthy();
|
||||
expect(validatePasswordStrength("abababababab")).toBeTruthy();
|
||||
});
|
||||
|
||||
it("weist Zeichenfolgen ab", () => {
|
||||
expect(validatePasswordStrength("abcdefghijkl")).toBeTruthy();
|
||||
expect(validatePasswordStrength("87654321abcd")).toBeTruthy();
|
||||
});
|
||||
|
||||
it("weist Passwoerter mit dem Benutzernamen ab", () => {
|
||||
expect(validatePasswordStrength("chefin-geheimnis", "chefin")).toMatch(/Benutzernamen/);
|
||||
// Ohne Benutzernamen ist dasselbe Passwort in Ordnung.
|
||||
expect(validatePasswordStrength("chefin-geheimnis")).toBeNull();
|
||||
// Sehr kurze Namen zaehlen nicht – sonst scheitert fast alles.
|
||||
expect(validatePasswordStrength("ab-langes-passwort", "ab")).toBeNull();
|
||||
});
|
||||
|
||||
it("laesst ein gutes Passwort mit Wiederholung durch", () => {
|
||||
// Ein "ll" ist kein Grund zur Ablehnung, solange genug Vielfalt da ist.
|
||||
expect(validatePasswordStrength("Rollladen-Fenster-42")).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
+122
-10
@@ -17,11 +17,24 @@ const scrypt = promisify(scryptCallback) as (
|
||||
options: { N: number; r: number; p: number; maxmem: number },
|
||||
) => Promise<Buffer>;
|
||||
|
||||
const PARAMS = { N: 32768, r: 8, p: 1 };
|
||||
/**
|
||||
* Arbeitsaufwand nach der Empfehlung des OWASP Password Storage Cheat Sheet:
|
||||
* N = 2^17, r = 8, p = 1. Frueher stand hier N = 2^15 mit p = 1 – das liegt
|
||||
* unter *jeder* der dort genannten zulaessigen Kombinationen (zu 2^15
|
||||
* gehoerte p = 3) und war damit rund dreimal billiger zu knacken als
|
||||
* vorgesehen.
|
||||
*
|
||||
* Gemessen kostet das rund 0,5 s je Pruefung und 128 MiB. Der Speicher
|
||||
* klingt nach viel, ist aber gedeckelt: Node rechnet scrypt im
|
||||
* libuv-Threadpool, standardmaessig vier Faeden parallel. Mehr als rund
|
||||
* 512 MiB koennen also nicht gleichzeitig belegt sein, und davor liegen
|
||||
* noch die Ratenbegrenzungen je IP und je Benutzername.
|
||||
*/
|
||||
const PARAMS = { N: 131072, r: 8, p: 1 };
|
||||
const KEY_LENGTH = 64;
|
||||
// scrypt braucht rund 128 * N * r Bytes; der Standardwert von 32 MB reicht
|
||||
// dafuer nicht ganz.
|
||||
const MAX_MEM = 96 * 1024 * 1024;
|
||||
// scrypt braucht rund 128 * N * r Bytes – bei diesen Werten 128 MiB.
|
||||
// Etwas Luft nach oben, damit die Pruefung nicht am Deckel scheitert.
|
||||
const MAX_MEM = 192 * 1024 * 1024;
|
||||
|
||||
export async function hashPassword(password: string): Promise<string> {
|
||||
const salt = randomBytes(16);
|
||||
@@ -72,6 +85,30 @@ export async function verifyPassword(
|
||||
return timingSafeEqual(derived, expected);
|
||||
}
|
||||
|
||||
/**
|
||||
* Ist der gespeicherte Hash mit schwaecheren Parametern erzeugt worden als
|
||||
* heute ueblich?
|
||||
*
|
||||
* Der Aufwand laesst sich nur fuer neue Passwoerter anheben – bestehende
|
||||
* Hashes bleiben sonst fuer immer auf dem alten Stand. OWASP empfiehlt
|
||||
* deshalb, bei der naechsten erfolgreichen Anmeldung still neu zu hashen.
|
||||
* Das geht nur dort, weil das Klartextpasswort ausschliesslich in diesem
|
||||
* Moment vorliegt.
|
||||
*/
|
||||
export function needsRehash(stored: string | null | undefined): boolean {
|
||||
if (!stored) return false;
|
||||
|
||||
const parts = stored.split("$");
|
||||
if (parts.length !== 6 || parts[0] !== "scrypt") return true;
|
||||
|
||||
const [N, r, p] = [Number(parts[1]), Number(parts[2]), Number(parts[3])];
|
||||
if (!Number.isFinite(N) || !Number.isFinite(r) || !Number.isFinite(p)) return true;
|
||||
|
||||
// Verglichen wird der Gesamtaufwand, nicht Feld fuer Feld: N=2^16 mit p=2
|
||||
// ist nach OWASP genauso zulaessig wie N=2^17 mit p=1.
|
||||
return N * r * p < PARAMS.N * PARAMS.r * PARAMS.p;
|
||||
}
|
||||
|
||||
/**
|
||||
* Verbrennt vergleichbar viel Zeit wie eine echte Pruefung. Wird aufgerufen,
|
||||
* wenn es den Benutzernamen gar nicht gibt – sonst liesse sich an der
|
||||
@@ -84,27 +121,102 @@ export async function fakeVerifyDelay(): Promise<void> {
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Naheliegende Passwoerter.
|
||||
*
|
||||
* ASVS 2.1.7 verlangt einen Abgleich gegen bekannte geleakte Passwoerter.
|
||||
* Ein Dienst wie Have-I-Been-Pwned schiede dafuer aus – Nebula ruft
|
||||
* grundsaetzlich nichts von aussen, und ein Passwort-Praefix nach draussen
|
||||
* zu geben widerspraeche dem erst recht. Diese Liste ist der Kompromiss:
|
||||
* die haeufigsten deutschen und englischen Kandidaten, dazu weiter unten
|
||||
* Muster statt Einzelwoerter, was mehr abdeckt als jede Liste dieser Groesse.
|
||||
*/
|
||||
const OBVIOUS = new Set([
|
||||
"password", "passwort", "12345678", "123456789", "1234567890",
|
||||
"qwertzuiop", "qwertyuiop", "administrator", "changeme", "letmein",
|
||||
"willkommen", "nebula123", "geheim123",
|
||||
// Klassiker
|
||||
"password", "password1", "password123", "passwort", "passwort1",
|
||||
"passwort123", "kennwort", "geheim", "geheim123", "changeme", "letmein",
|
||||
"welcome", "willkommen", "willkommen1", "administrator", "admin1234",
|
||||
"iloveyou", "sunshine", "princess", "dragon", "monkey", "football",
|
||||
"baseball", "superman", "trustno1", "starwars", "whatever", "freedom",
|
||||
// Zahlen und Tastaturlaeufe
|
||||
"12345678", "123456789", "1234567890", "87654321", "11111111",
|
||||
"qwertzuiop", "qwertyuiop", "asdfghjkl", "qwertz123", "qwerty123",
|
||||
"1qay2wsx", "1q2w3e4r", "1q2w3e4r5t", "asdf1234", "qwer1234",
|
||||
// Deutsch
|
||||
"sommer2024", "sommer2025", "sommer2026", "winter2024", "winter2025",
|
||||
"winter2026", "fussball", "deutschland", "hallowelt", "sonnenschein",
|
||||
"schatz123", "liebling", "blumen123", "internet", "computer",
|
||||
// Projektnah
|
||||
"nebula", "nebula123", "nebula2026", "dashboard", "vibecoding",
|
||||
]);
|
||||
|
||||
export { PASSWORD_MIN_LENGTH };
|
||||
|
||||
/** Gibt eine Fehlermeldung zurueck oder null, wenn das Passwort taugt. */
|
||||
export function validatePasswordStrength(password: string): string | null {
|
||||
/**
|
||||
* Laenge der laengsten auf- oder absteigenden Zeichenfolge ("abcd", "4321").
|
||||
*
|
||||
* Zurueckgegeben wird die Laenge und nicht nur ein Ja/Nein: entscheidend ist,
|
||||
* *wie viel* des Passworts aus der Folge besteht. Ein "de" mitten in einem
|
||||
* Wort ist harmlos, "abcdefghijkl" ist das ganze Passwort.
|
||||
*/
|
||||
function laengsteFolge(wert: string): number {
|
||||
if (wert.length < 2) return wert.length;
|
||||
let beste = 1;
|
||||
let auf = 1;
|
||||
let ab = 1;
|
||||
for (let i = 1; i < wert.length; i += 1) {
|
||||
const schritt = wert.charCodeAt(i) - wert.charCodeAt(i - 1);
|
||||
auf = schritt === 1 ? auf + 1 : 1;
|
||||
ab = schritt === -1 ? ab + 1 : 1;
|
||||
beste = Math.max(beste, auf, ab);
|
||||
}
|
||||
return beste;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gibt eine Fehlermeldung zurueck oder null, wenn das Passwort taugt.
|
||||
*
|
||||
* Bewusst **keine** Zusammensetzungsregeln ("mindestens ein Sonderzeichen").
|
||||
* ASVS 2.1.9 raet ausdruecklich davon ab: sie treiben Leute zu "Passwort1!"
|
||||
* und senken die Entropie, statt sie zu heben. Geprueft wird stattdessen
|
||||
* auf Laenge und auf das, was nachweislich schwach ist.
|
||||
*/
|
||||
export function validatePasswordStrength(
|
||||
password: string,
|
||||
/** Benutzername des Kontos, falls bekannt – er darf nicht im Passwort stehen. */
|
||||
username?: string | null,
|
||||
): string | null {
|
||||
if (password.length < PASSWORD_MIN_LENGTH) {
|
||||
return `Das Passwort muss mindestens ${PASSWORD_MIN_LENGTH} Zeichen haben.`;
|
||||
}
|
||||
if (password.length > 200) {
|
||||
return "Das Passwort darf hoechstens 200 Zeichen haben.";
|
||||
}
|
||||
if (OBVIOUS.has(password.toLowerCase())) {
|
||||
|
||||
const klein = password.toLowerCase();
|
||||
|
||||
if (OBVIOUS.has(klein)) {
|
||||
return "Dieses Passwort ist zu naheliegend.";
|
||||
}
|
||||
if (/^\d+$/.test(password)) {
|
||||
return "Nur Ziffern reichen nicht – bitte Buchstaben oder Zeichen ergaenzen.";
|
||||
}
|
||||
// Zu wenig verschiedene Zeichen – deckt "aaaaaaaa" ebenso ab wie
|
||||
// "abababab" oder "12121212", ohne dafuer je ein eigenes Muster zu
|
||||
// brauchen.
|
||||
if (new Set(klein).size <= 4) {
|
||||
return "Das Passwort benutzt zu wenige verschiedene Zeichen.";
|
||||
}
|
||||
// Und wenn der groesste Teil des Passworts eine durchlaufende Folge ist.
|
||||
if (laengsteFolge(klein) >= Math.max(6, Math.ceil(password.length * 0.6))) {
|
||||
return "Zeichenfolgen wie „abcd“ oder „4321“ sind zu leicht zu raten.";
|
||||
}
|
||||
// Ein Passwort, das den Benutzernamen enthaelt, ist der erste Versuch
|
||||
// jedes Angreifers.
|
||||
const name = username?.trim().toLowerCase();
|
||||
if (name && name.length >= 3 && klein.includes(name)) {
|
||||
return "Das Passwort darf den Benutzernamen nicht enthalten.";
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
+33
-6
@@ -2,7 +2,12 @@ import { createHash, randomBytes } from "node:crypto";
|
||||
import { cookies } from "next/headers";
|
||||
import type { NextResponse } from "next/server";
|
||||
import type { User } from "@prisma/client";
|
||||
import { COOKIES_SECURE, SESSION_COOKIE, SESSION_TTL_MS } from "@/lib/config";
|
||||
import {
|
||||
COOKIES_SECURE,
|
||||
SESSION_COOKIE,
|
||||
SESSION_IDLE_MS,
|
||||
SESSION_TTL_MS,
|
||||
} from "@/lib/config";
|
||||
import { prisma } from "@/lib/db";
|
||||
|
||||
/**
|
||||
@@ -68,7 +73,10 @@ export function setSessionCookie(response: NextResponse, token: string, expiresA
|
||||
name: SESSION_COOKIE,
|
||||
value: token,
|
||||
httpOnly: true,
|
||||
sameSite: "lax",
|
||||
// Strict statt Lax: Nebula hat keinen Einstieg von aussen, den eine
|
||||
// fremde Seite anstossen duerfte. Der Preis ist, dass ein Klick von
|
||||
// einer anderen Seite auf die Anmeldung fuehrt – ein Neuladen genuegt.
|
||||
sameSite: "strict",
|
||||
secure: COOKIES_SECURE,
|
||||
path: "/",
|
||||
expires: expiresAt,
|
||||
@@ -80,7 +88,10 @@ export function clearSessionCookie(response: NextResponse) {
|
||||
name: SESSION_COOKIE,
|
||||
value: "",
|
||||
httpOnly: true,
|
||||
sameSite: "lax",
|
||||
// Strict statt Lax: Nebula hat keinen Einstieg von aussen, den eine
|
||||
// fremde Seite anstossen duerfte. Der Preis ist, dass ein Klick von
|
||||
// einer anderen Seite auf die Anmeldung fuehrt – ein Neuladen genuegt.
|
||||
sameSite: "strict",
|
||||
secure: COOKIES_SECURE,
|
||||
path: "/",
|
||||
maxAge: 0,
|
||||
@@ -109,11 +120,27 @@ export async function getSessionUser(): Promise<SessionUser | null> {
|
||||
return null;
|
||||
}
|
||||
|
||||
// Leerlaufgrenze. Vorher wurde lastSeenAt zwar gefuehrt, aber nie
|
||||
// ausgewertet – ein abgegriffener Cookie galt damit bis zum absoluten
|
||||
// Ablauf, auch wenn das Konto wochenlang unberuehrt war.
|
||||
const untaetig = Date.now() - session.lastSeenAt.getTime();
|
||||
if (SESSION_IDLE_MS > 0 && untaetig > SESSION_IDLE_MS) {
|
||||
await prisma.session.delete({ where: { id: session.id } }).catch(() => undefined);
|
||||
return null;
|
||||
}
|
||||
|
||||
if (!session.user.isActive) return null;
|
||||
|
||||
// Hoechstens einmal pro Stunde schreiben, damit nicht jede Anfrage die
|
||||
// Datenbank anfasst.
|
||||
if (Date.now() - session.lastSeenAt.getTime() > 60 * 60 * 1000) {
|
||||
/**
|
||||
* lastSeenAt nachfuehren, aber nicht bei jeder Anfrage schreiben.
|
||||
*
|
||||
* Das Intervall muss deutlich unter der Leerlaufgrenze liegen, sonst
|
||||
* verkuerzt die Schreibbremse sie: bei stuendlichem Schreiben und einer
|
||||
* Grenze von einer Stunde waere die Sitzung schon nach Sekunden faellig.
|
||||
* Ein Zwanzigstel der Frist, hoechstens fuenf Minuten.
|
||||
*/
|
||||
const intervall = SESSION_IDLE_MS > 0 ? Math.min(SESSION_IDLE_MS / 20, 5 * 60 * 1000) : 60 * 60 * 1000;
|
||||
if (untaetig > intervall) {
|
||||
void prisma.session
|
||||
.update({ where: { id: session.id }, data: { lastSeenAt: new Date() } })
|
||||
.catch(() => undefined);
|
||||
|
||||
@@ -41,6 +41,100 @@ export const KIND_META: Record<ChangeKind, { label: string; className: string }>
|
||||
};
|
||||
|
||||
export const CHANGELOG: Release[] = [
|
||||
{
|
||||
version: "1.9.0",
|
||||
date: "2026-08-17",
|
||||
headline: "Geschlossene Issues haken ihre Aufgabe auch ohne Webhook ab.",
|
||||
changes: [
|
||||
{
|
||||
kind: "neu",
|
||||
text:
|
||||
"Der Abgleich prüft jetzt den Zustand verknüpfter Issues: was in Git geschlossen " +
|
||||
"wurde, wird in Nebula abgehakt. Bisher konnte das nur der Webhook — war keiner " +
|
||||
"eingerichtet, blieb der Rückweg ganz aus.",
|
||||
},
|
||||
{
|
||||
kind: "besser",
|
||||
text:
|
||||
"Ein über Git geschlossenes Issue bewirkt jetzt dasselbe wie ein Haken in der " +
|
||||
"Oberfläche: bei wiederkehrenden Aufgaben entsteht die nächste Fassung, und der " +
|
||||
"Vorgang steht im Projektverlauf.",
|
||||
},
|
||||
],
|
||||
},
|
||||
{
|
||||
version: "1.8.0",
|
||||
date: "2026-08-15",
|
||||
headline: "Durchgang durch Anmeldung und Sitzungen nach OWASP.",
|
||||
changes: [
|
||||
{
|
||||
kind: "besser",
|
||||
text:
|
||||
"Passwörter werden deutlich aufwendiger gehasht (scrypt mit N=2^17 statt 2^15) — " +
|
||||
"das entspricht der Empfehlung des OWASP Password Storage Cheat Sheet. Bestehende " +
|
||||
"Passwörter werden bei der nächsten Anmeldung still auf den neuen Stand gebracht.",
|
||||
},
|
||||
{
|
||||
kind: "behoben",
|
||||
text:
|
||||
"Die Anmeldung verriet, welche Benutzernamen existieren: gesperrte, deaktivierte " +
|
||||
"und reine Passkey-Konten antworteten anders als unbekannte — und das schon vor " +
|
||||
"der Passwortprüfung. Jetzt gibt es die Auskunft erst, wenn das Passwort stimmt.",
|
||||
},
|
||||
{
|
||||
kind: "neu",
|
||||
text:
|
||||
"Sitzungen laufen nach acht Stunden ohne Nutzung ab, zusätzlich zur bestehenden " +
|
||||
"Frist von 30 Tagen. Einstellbar über SESSION_IDLE_HOURS; 0 schaltet es ab.",
|
||||
},
|
||||
{
|
||||
kind: "besser",
|
||||
text:
|
||||
"Das Sitzungscookie trägt bei HTTPS den Präfix „__Host-“ und gilt nur noch " +
|
||||
"SameSite=Strict. Beides muss einmalig neu angemeldet werden.",
|
||||
},
|
||||
{
|
||||
kind: "besser",
|
||||
text:
|
||||
"Die Passwortprüfung erkennt jetzt Wiederholungen, Zeichenfolgen und Passwörter, " +
|
||||
"die den eigenen Benutzernamen enthalten.",
|
||||
},
|
||||
],
|
||||
},
|
||||
{
|
||||
version: "1.7.0",
|
||||
date: "2026-08-15",
|
||||
headline: "Aufgaben und Git-Issues finden zusammen.",
|
||||
changes: [
|
||||
{
|
||||
kind: "neu",
|
||||
text:
|
||||
"Eine Aufgabe lässt sich als Issue im verknüpften Repository anlegen — per Knopf, " +
|
||||
"nie nebenbei. Danach wandert der Zustand mit: erledigt schließt das Issue, ein " +
|
||||
"Zurückziehen öffnet es wieder.",
|
||||
},
|
||||
{
|
||||
kind: "neu",
|
||||
text:
|
||||
"Webhooks. Ein Push aktualisiert den Stand sofort, statt bis zum nächsten " +
|
||||
"Abgleich zu warten; ein geschlossenes Issue hakt seine Aufgabe ab. Einzurichten " +
|
||||
"am Repository — URL und Geheimnis stehen dort bereit.",
|
||||
},
|
||||
{
|
||||
kind: "behoben",
|
||||
text:
|
||||
"Auf dem Telefon verdeckte die Bildschirmtastatur den halben Dialog, weil er mit " +
|
||||
"der vollen Fensterhöhe rechnete. Dialoge richten sich jetzt nach dem sichtbaren " +
|
||||
"Bereich und rücken über die Tastatur.",
|
||||
},
|
||||
{
|
||||
kind: "besser",
|
||||
text:
|
||||
"Aufgaben lassen sich in der Übersicht direkt bearbeiten. Bisher führte von dort " +
|
||||
"nur der Weg ins Projekt.",
|
||||
},
|
||||
],
|
||||
},
|
||||
{
|
||||
version: "1.6.0",
|
||||
date: "2026-08-14",
|
||||
|
||||
+32
-3
@@ -73,18 +73,47 @@ export const WEBAUTHN_AVAILABLE =
|
||||
/** Cookies nur ueber TLS ausliefern, wenn die App per https laeuft. */
|
||||
export const COOKIES_SECURE = APP_URL_PARSED.protocol === "https:";
|
||||
|
||||
/** Lebensdauer einer Sitzung. */
|
||||
/**
|
||||
* Absolute Lebensdauer einer Sitzung – ab Anmeldung, nicht verlaengerbar.
|
||||
* Nach dieser Frist ist Schluss, egal wie aktiv jemand war.
|
||||
*/
|
||||
export const SESSION_TTL_DAYS = Number(process.env.SESSION_TTL_DAYS ?? 30);
|
||||
export const SESSION_TTL_MS = SESSION_TTL_DAYS * 24 * 60 * 60 * 1000;
|
||||
|
||||
export const SESSION_COOKIE = "nebula_session";
|
||||
/**
|
||||
* Leerlauffrist: so lange darf eine Sitzung unbenutzt bleiben.
|
||||
*
|
||||
* ASVS 3.3.2 verlangt beides – eine absolute *und* eine Leerlaufgrenze.
|
||||
* Vorher gab es nur die absolute, ein abgegriffener Cookie galt also bis zu
|
||||
* 30 Tage, unabhaengig davon, ob das Konto benutzt wurde.
|
||||
*
|
||||
* Acht Stunden sind der Kompromiss: ein Arbeitstag am Stueck bleibt
|
||||
* angemeldet, ueber Nacht laeuft die Sitzung ab. Wem das zu streng ist,
|
||||
* setzt SESSION_IDLE_HOURS hoch; 0 schaltet die Leerlaufgrenze ab.
|
||||
*/
|
||||
export const SESSION_IDLE_HOURS = Number(process.env.SESSION_IDLE_HOURS ?? 8);
|
||||
export const SESSION_IDLE_MS =
|
||||
SESSION_IDLE_HOURS > 0 ? SESSION_IDLE_HOURS * 60 * 60 * 1000 : 0;
|
||||
|
||||
/**
|
||||
* Name des Sitzungscookies.
|
||||
*
|
||||
* Mit dem Praefix "__Host-" erzwingt der Browser selbst, was wir ohnehin
|
||||
* setzen: Secure, Pfad "/" und kein Domain-Attribut. Letzteres ist der
|
||||
* eigentliche Gewinn – eine andere Subdomain kann den Cookie dann nicht
|
||||
* ueberschreiben und damit keine Sitzung unterschieben.
|
||||
*
|
||||
* Nur bei https, denn der Praefix verlangt zwingend Secure; ohne TLS wuerde
|
||||
* der Browser den Cookie schlicht verwerfen.
|
||||
*/
|
||||
export const SESSION_COOKIE = COOKIES_SECURE ? "__Host-nebula_session" : "nebula_session";
|
||||
|
||||
/**
|
||||
* Cookie fuer die halbfertige Anmeldung zwischen Passwort und zweitem Faktor.
|
||||
* Kurzlebig – wer den Code nicht binnen fuenf Minuten eingibt, faengt von
|
||||
* vorne an.
|
||||
*/
|
||||
export const MFA_COOKIE = "nebula_mfa";
|
||||
export const MFA_COOKIE = COOKIES_SECURE ? "__Host-nebula_mfa" : "nebula_mfa";
|
||||
export const MFA_TTL_MS = 5 * 60 * 1000;
|
||||
|
||||
/** Wird beim Start einmal geloggt, damit Fehlkonfiguration frueh auffaellt. */
|
||||
|
||||
+37
-1
@@ -1,4 +1,4 @@
|
||||
import { getJson, getJsonSafe, normalizeBaseUrl, shortSha, toIso } from "./http";
|
||||
import { getJson, getJsonSafe, normalizeBaseUrl, sendJson, shortSha, toIso } from "./http";
|
||||
import {
|
||||
CALENDAR_PAGE_SIZE,
|
||||
calendarByPaging,
|
||||
@@ -12,6 +12,7 @@ import type {
|
||||
CiState,
|
||||
CommitInfo,
|
||||
ConnectionCheck,
|
||||
CreatedIssue,
|
||||
GitClient,
|
||||
ProviderConfig,
|
||||
ReleaseInfo,
|
||||
@@ -44,6 +45,41 @@ export class GiteaClient implements GitClient {
|
||||
return headers;
|
||||
}
|
||||
|
||||
private repoBase(ref: RepoRef): string {
|
||||
return `${this.apiBase}/repos/${encodeURIComponent(ref.owner)}/${encodeURIComponent(ref.name)}`;
|
||||
}
|
||||
|
||||
async createIssue(
|
||||
ref: RepoRef,
|
||||
issue: { title: string; body?: string | null },
|
||||
): Promise<CreatedIssue> {
|
||||
const angelegt = await sendJson<{ number: number; html_url?: string }>(
|
||||
`${this.repoBase(ref)}/issues`,
|
||||
"POST",
|
||||
{ title: issue.title, body: issue.body ?? "" },
|
||||
{ headers: this.headers() },
|
||||
);
|
||||
return { number: angelegt.number, url: angelegt.html_url ?? null };
|
||||
}
|
||||
|
||||
async setIssueState(ref: RepoRef, number: number, open: boolean): Promise<void> {
|
||||
await sendJson(
|
||||
`${this.repoBase(ref)}/issues/${number}`,
|
||||
"PATCH",
|
||||
{ state: open ? "open" : "closed" },
|
||||
{ headers: this.headers() },
|
||||
);
|
||||
}
|
||||
|
||||
async getIssueState(ref: RepoRef, number: number): Promise<"open" | "closed" | null> {
|
||||
const issue = await getJson<{ state?: string } | null>(
|
||||
`${this.repoBase(ref)}/issues/${number}`,
|
||||
{ headers: this.headers(), allow404: true },
|
||||
);
|
||||
if (!issue?.state) return null;
|
||||
return issue.state === "closed" ? "closed" : "open";
|
||||
}
|
||||
|
||||
async check(): Promise<ConnectionCheck> {
|
||||
try {
|
||||
const version = await getJsonSafe<{ version?: string }>(
|
||||
|
||||
+37
-1
@@ -1,4 +1,4 @@
|
||||
import { getJson, getJsonSafe, normalizeBaseUrl, shortSha, toIso } from "./http";
|
||||
import { getJson, getJsonSafe, normalizeBaseUrl, sendJson, shortSha, toIso } from "./http";
|
||||
import type {
|
||||
BranchInfo,
|
||||
CiInfo,
|
||||
@@ -6,6 +6,7 @@ import type {
|
||||
CommitCalendar,
|
||||
CommitInfo,
|
||||
ConnectionCheck,
|
||||
CreatedIssue,
|
||||
GitClient,
|
||||
ProviderConfig,
|
||||
ReleaseInfo,
|
||||
@@ -43,6 +44,41 @@ export class GitHubClient implements GitClient {
|
||||
return headers;
|
||||
}
|
||||
|
||||
private repoBase(ref: RepoRef): string {
|
||||
return `${this.apiBase}/repos/${encodeURIComponent(ref.owner)}/${encodeURIComponent(ref.name)}`;
|
||||
}
|
||||
|
||||
async createIssue(
|
||||
ref: RepoRef,
|
||||
issue: { title: string; body?: string | null },
|
||||
): Promise<CreatedIssue> {
|
||||
const angelegt = await sendJson<{ number: number; html_url?: string }>(
|
||||
`${this.repoBase(ref)}/issues`,
|
||||
"POST",
|
||||
{ title: issue.title, body: issue.body ?? "" },
|
||||
{ headers: this.headers() },
|
||||
);
|
||||
return { number: angelegt.number, url: angelegt.html_url ?? null };
|
||||
}
|
||||
|
||||
async setIssueState(ref: RepoRef, number: number, open: boolean): Promise<void> {
|
||||
await sendJson(
|
||||
`${this.repoBase(ref)}/issues/${number}`,
|
||||
"PATCH",
|
||||
{ state: open ? "open" : "closed" },
|
||||
{ headers: this.headers() },
|
||||
);
|
||||
}
|
||||
|
||||
async getIssueState(ref: RepoRef, number: number): Promise<"open" | "closed" | null> {
|
||||
const issue = await getJson<{ state?: string } | null>(
|
||||
`${this.repoBase(ref)}/issues/${number}`,
|
||||
{ headers: this.headers(), allow404: true },
|
||||
);
|
||||
if (!issue?.state) return null;
|
||||
return issue.state === "closed" ? "closed" : "open";
|
||||
}
|
||||
|
||||
async check(): Promise<ConnectionCheck> {
|
||||
try {
|
||||
if (!this.token) {
|
||||
|
||||
+36
-1
@@ -1,4 +1,4 @@
|
||||
import { getJson, getJsonSafe, normalizeBaseUrl, shortSha, toIso } from "./http";
|
||||
import { getJson, getJsonSafe, normalizeBaseUrl, sendJson, shortSha, toIso } from "./http";
|
||||
import {
|
||||
CALENDAR_PAGE_SIZE,
|
||||
calendarByPaging,
|
||||
@@ -12,6 +12,7 @@ import type {
|
||||
CiState,
|
||||
CommitInfo,
|
||||
ConnectionCheck,
|
||||
CreatedIssue,
|
||||
GitClient,
|
||||
ProviderConfig,
|
||||
ReleaseInfo,
|
||||
@@ -45,6 +46,40 @@ export class GitLabClient implements GitClient {
|
||||
return headers;
|
||||
}
|
||||
|
||||
async createIssue(
|
||||
ref: RepoRef,
|
||||
issue: { title: string; body?: string | null },
|
||||
): Promise<CreatedIssue> {
|
||||
// GitLab nennt es "iid" – die projektinterne Nummer, die auch in der
|
||||
// Oberflaeche steht. "id" waere die instanzweite und damit die falsche.
|
||||
const angelegt = await sendJson<{ iid: number; web_url?: string }>(
|
||||
`${this.apiBase}/projects/${this.projectPath(ref)}/issues`,
|
||||
"POST",
|
||||
{ title: issue.title, description: issue.body ?? "" },
|
||||
{ headers: this.headers() },
|
||||
);
|
||||
return { number: angelegt.iid, url: angelegt.web_url ?? null };
|
||||
}
|
||||
|
||||
async setIssueState(ref: RepoRef, number: number, open: boolean): Promise<void> {
|
||||
await sendJson(
|
||||
`${this.apiBase}/projects/${this.projectPath(ref)}/issues/${number}`,
|
||||
"PUT",
|
||||
{ state_event: open ? "reopen" : "close" },
|
||||
{ headers: this.headers() },
|
||||
);
|
||||
}
|
||||
|
||||
async getIssueState(ref: RepoRef, number: number): Promise<"open" | "closed" | null> {
|
||||
const issue = await getJson<{ state?: string } | null>(
|
||||
`${this.apiBase}/projects/${this.projectPath(ref)}/issues/${number}`,
|
||||
{ headers: this.headers(), allow404: true },
|
||||
);
|
||||
if (!issue?.state) return null;
|
||||
// GitLab nennt den offenen Zustand "opened".
|
||||
return issue.state === "closed" ? "closed" : "open";
|
||||
}
|
||||
|
||||
async check(): Promise<ConnectionCheck> {
|
||||
try {
|
||||
if (!this.token) {
|
||||
|
||||
@@ -98,6 +98,83 @@ export async function getJson<T>(
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Schreibender Aufruf – POST, PATCH oder PUT.
|
||||
*
|
||||
* Bewusst dieselbe Schleuse wie getJson: die Basis-URL stammt aus einem
|
||||
* Formular, und ohne die Pruefung waere ein schreibender Aufruf der weitaus
|
||||
* unangenehmere Weg nach innen. Redirects werden hier **nicht** verfolgt.
|
||||
* Ein 307 auf eine interne Adresse wuerde den Rumpf mitnehmen, und der
|
||||
* enthaelt bei uns immer den Token im Header – lieber ein Fehler als eine
|
||||
* Anfrage, die woanders landet.
|
||||
*/
|
||||
export async function sendJson<T>(
|
||||
url: string,
|
||||
method: "POST" | "PATCH" | "PUT",
|
||||
body: unknown,
|
||||
options: FetchOptions = {},
|
||||
): Promise<T> {
|
||||
const controller = new AbortController();
|
||||
const timeout = setTimeout(
|
||||
() => controller.abort(),
|
||||
options.timeoutMs ?? DEFAULT_TIMEOUT,
|
||||
);
|
||||
|
||||
try {
|
||||
await assertAllowedUrl(url);
|
||||
|
||||
const response = await fetch(url, {
|
||||
method,
|
||||
headers: {
|
||||
Accept: "application/json",
|
||||
"Content-Type": "application/json",
|
||||
"User-Agent": "Nebula-Dashboard",
|
||||
...options.headers,
|
||||
},
|
||||
body: JSON.stringify(body),
|
||||
signal: controller.signal,
|
||||
cache: "no-store",
|
||||
redirect: "manual",
|
||||
});
|
||||
|
||||
// Bei redirect: "manual" kommt der Umleitungsstatus durch, statt dass
|
||||
// fetch ihm folgt. Das ist hier gewollt und ein Fehlerfall.
|
||||
if (response.status >= 300 && response.status < 400) {
|
||||
throw new GitApiError(
|
||||
"Das Git-System hat umgeleitet. Schreibende Aufrufe folgen dem nicht – " +
|
||||
"bitte die Basis-URL der Verbindung auf die endgueltige Adresse setzen.",
|
||||
response.status,
|
||||
url,
|
||||
);
|
||||
}
|
||||
|
||||
if (!response.ok) {
|
||||
const text = await response.text().catch(() => "");
|
||||
throw new GitApiError(friendlyMessage(response.status, url, text), response.status, url);
|
||||
}
|
||||
|
||||
const text = await response.text();
|
||||
if (!text) return null as T;
|
||||
return JSON.parse(text) as T;
|
||||
} catch (error) {
|
||||
if (error instanceof GitApiError) throw error;
|
||||
if (error instanceof BlockedHostError) {
|
||||
throw new GitApiError(error.message, 403, url);
|
||||
}
|
||||
if (error instanceof Error && error.name === "AbortError") {
|
||||
throw new GitApiError(
|
||||
`Zeitueberschreitung nach ${options.timeoutMs ?? DEFAULT_TIMEOUT} ms`,
|
||||
408,
|
||||
url,
|
||||
);
|
||||
}
|
||||
const reason = error instanceof Error ? error.message : String(error);
|
||||
throw new GitApiError(`Verbindung fehlgeschlagen: ${reason}`, 0, url);
|
||||
} finally {
|
||||
clearTimeout(timeout);
|
||||
}
|
||||
}
|
||||
|
||||
/** Wie getJson, gibt aber bei jedem Fehler den Fallback zurueck. */
|
||||
export async function getJsonSafe<T>(
|
||||
url: string,
|
||||
|
||||
@@ -167,10 +167,40 @@ export interface ProviderConfig {
|
||||
token: string | null;
|
||||
}
|
||||
|
||||
/** Ein neu angelegtes Issue, so weit wir es zurueckschreiben. */
|
||||
export interface CreatedIssue {
|
||||
number: number;
|
||||
url: string | null;
|
||||
}
|
||||
|
||||
export interface GitClient {
|
||||
readonly provider: ProviderKind;
|
||||
/** Prueft Erreichbarkeit und Token-Gueltigkeit. */
|
||||
check(): Promise<ConnectionCheck>;
|
||||
/**
|
||||
* Legt ein Issue an und liefert Nummer und Adresse zurueck.
|
||||
*
|
||||
* Der einzige schreibende Aufruf in dieser Schnittstelle. Er wird nie
|
||||
* nebenbei ausgeloest, sondern immer von Hand angestossen – was nach
|
||||
* aussen geht, soll jemand gewollt haben.
|
||||
*/
|
||||
createIssue(ref: RepoRef, issue: { title: string; body?: string | null }): Promise<CreatedIssue>;
|
||||
/**
|
||||
* Schliesst ein Issue. Beim Zurueckziehen einer Aufgabe wird es wieder
|
||||
* geoeffnet – daher der Schalter statt zweier Methoden.
|
||||
*/
|
||||
setIssueState(ref: RepoRef, number: number, open: boolean): Promise<void>;
|
||||
/**
|
||||
* Liest den Zustand eines einzelnen Issues.
|
||||
*
|
||||
* Gebraucht fuer den Abgleich: der Snapshot fuehrt nur die *offenen*
|
||||
* Issues und ist ausserdem gedeckelt – aus dem Fehlen einer Nummer laesst
|
||||
* sich deshalb nicht schliessen, dass sie geschlossen wurde. Sie koennte
|
||||
* ebenso geloescht oder einfach jenseits des Deckels sein.
|
||||
*
|
||||
* null heisst: gibt es nicht (mehr).
|
||||
*/
|
||||
getIssueState(ref: RepoRef, number: number): Promise<"open" | "closed" | null>;
|
||||
/** Repos, auf die der Token Zugriff hat (fuer die Auswahl beim Verknuepfen). */
|
||||
listRepos(query?: string): Promise<RepoListItem[]>;
|
||||
/** Vollstaendiger Stand eines Repositories. */
|
||||
|
||||
+50
-1
@@ -65,17 +65,66 @@ export const connectionSafeSelect = Prisma.validator<Prisma.GitConnectionSelect>
|
||||
updatedAt: true,
|
||||
});
|
||||
|
||||
/**
|
||||
* Felder eines Repositories, die nach aussen duerfen.
|
||||
*
|
||||
* Ausdruecklich als Liste und nicht als "include": ein include liefert jedes
|
||||
* Skalarfeld mit, auch neu hinzugekommene. Das Webhook-Geheimnis waere so
|
||||
* still in jede Projektantwort und in jede Seite gewandert – verschluesselt
|
||||
* zwar, aber nach aussen gehoert es trotzdem nicht. Dieselbe Ueberlegung wie
|
||||
* bei connectionSafeSelect.
|
||||
*
|
||||
* Ob ein Webhook eingerichtet ist, sagt webhookLastAt nicht zuverlaessig
|
||||
* (frisch eingerichtet ist es null). Diese Angabe holt die Projektseite
|
||||
* deshalb getrennt – siehe webhookRepositoryIds.
|
||||
*/
|
||||
export const repositorySafeSelect = Prisma.validator<Prisma.RepositorySelect>()({
|
||||
id: true,
|
||||
projectId: true,
|
||||
label: true,
|
||||
repoUrl: true,
|
||||
repoOwner: true,
|
||||
repoName: true,
|
||||
defaultBranch: true,
|
||||
connectionId: true,
|
||||
position: true,
|
||||
lastSyncedAt: true,
|
||||
syncError: true,
|
||||
autoSync: true,
|
||||
syncFailureCount: true,
|
||||
notifiedSyncError: true,
|
||||
notifiedCiState: true,
|
||||
notifiedRelease: true,
|
||||
webhookLastAt: true,
|
||||
createdAt: true,
|
||||
updatedAt: true,
|
||||
connection: { select: connectionSafeSelect },
|
||||
snapshot: true,
|
||||
});
|
||||
|
||||
/**
|
||||
* Ein Repository mitsamt Verbindung und Stand. Die Reihenfolge ist ueberall
|
||||
* dieselbe: das fuehrende zuerst, denn auf der Karte ist nur fuer eines Platz.
|
||||
*/
|
||||
export const repositoryInclude = Prisma.validator<Prisma.ProjectInclude>()({
|
||||
repositories: {
|
||||
include: { connection: { select: connectionSafeSelect }, snapshot: true },
|
||||
select: repositorySafeSelect,
|
||||
orderBy: [{ position: "asc" }, { createdAt: "asc" }],
|
||||
},
|
||||
});
|
||||
|
||||
/**
|
||||
* IDs der Repositories eines Projekts, fuer die ein Webhook hinterlegt ist.
|
||||
* Getrennt geholt, damit das Geheimnis selbst nirgends mitgereicht wird.
|
||||
*/
|
||||
export async function webhookRepositoryIds(projectId: string): Promise<string[]> {
|
||||
const treffer = await prisma.repository.findMany({
|
||||
where: { projectId, webhookSecret: { not: null } },
|
||||
select: { id: true },
|
||||
});
|
||||
return treffer.map((eintrag) => eintrag.id);
|
||||
}
|
||||
|
||||
export const projectListInclude = Prisma.validator<Prisma.ProjectInclude>()({
|
||||
...repositoryInclude,
|
||||
_count: { select: { notes: true, tasks: true } },
|
||||
|
||||
+22
-1
@@ -5,6 +5,7 @@ import { clientForConnection, createClient, parseRepoUrl } from "@/lib/git";
|
||||
import type { GitClient } from "@/lib/git/types";
|
||||
import { notifyAfterSync } from "@/lib/notify";
|
||||
import { repoTitle } from "@/lib/repositories";
|
||||
import { reconcileLinkedIssues } from "@/lib/tasks/issues";
|
||||
import type { RepoSnapshotData } from "@/lib/git/types";
|
||||
|
||||
export interface SyncResult {
|
||||
@@ -62,11 +63,31 @@ export async function syncRepository(repositoryId: string): Promise<SyncResult>
|
||||
// README hineingeschrieben werden koennen.
|
||||
await maybeRefreshCalendar(repository.id, client, ref);
|
||||
await maybeRefreshReadme(repository.id, client, ref);
|
||||
|
||||
/**
|
||||
* Verknuepfte Aufgaben nachziehen: was in Git geschlossen wurde, wird
|
||||
* hier abgehakt. Der Webhook macht das sofort – ist keiner eingerichtet
|
||||
* oder faellt er aus, greift der Abgleich.
|
||||
*
|
||||
* Die offenen Issues aus dem gerade geholten Snapshot gehen mit hinein:
|
||||
* fuer jede Nummer, die dort steht, ist die Nachfrage gespart.
|
||||
*/
|
||||
const abgehakt = await reconcileLinkedIssues(
|
||||
repository.id,
|
||||
client,
|
||||
ref,
|
||||
data.issues.map((issue) => issue.number),
|
||||
);
|
||||
|
||||
// Nach dem Speichern, damit die Meldung den neuen Stand sieht.
|
||||
await notifyAfterSync(repository.id);
|
||||
return {
|
||||
ok: true,
|
||||
message: `Snapshot aktualisiert: ${data.branches.length} Branches, ${data.tags.length} Tags.`,
|
||||
message:
|
||||
`Snapshot aktualisiert: ${data.branches.length} Branches, ${data.tags.length} Tags.` +
|
||||
(abgehakt > 0
|
||||
? ` ${abgehakt} Aufgabe(n) abgehakt, weil das Issue geschlossen wurde.`
|
||||
: ""),
|
||||
fetchedAt: new Date().toISOString(),
|
||||
};
|
||||
} catch (error) {
|
||||
|
||||
@@ -0,0 +1,43 @@
|
||||
import { describe, expect, it } from "vitest";
|
||||
import { issueShouldBeOpen, statusForIssueState } from "./issues";
|
||||
|
||||
describe("issueShouldBeOpen", () => {
|
||||
it("haelt das Issue offen, solange die Aufgabe nicht erledigt ist", () => {
|
||||
expect(issueShouldBeOpen("TODO")).toBe(true);
|
||||
expect(issueShouldBeOpen("DOING")).toBe(true);
|
||||
expect(issueShouldBeOpen("BLOCKED")).toBe(true);
|
||||
});
|
||||
|
||||
it("schliesst es erst bei ERLEDIGT", () => {
|
||||
expect(issueShouldBeOpen("DONE")).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe("statusForIssueState", () => {
|
||||
it("macht aus einem geschlossenen Issue eine erledigte Aufgabe", () => {
|
||||
expect(statusForIssueState(false, "TODO")).toBe("DONE");
|
||||
expect(statusForIssueState(false, "DOING")).toBe("DONE");
|
||||
});
|
||||
|
||||
it("holt eine erledigte Aufgabe zurueck nach OFFEN", () => {
|
||||
expect(statusForIssueState(true, "DONE")).toBe("TODO");
|
||||
});
|
||||
|
||||
it("laesst den feineren Zustand stehen, wenn das Issue ohnehin offen ist", () => {
|
||||
// Ein "opened"-Ereignis zu einer Aufgabe, die schon in Arbeit ist, darf
|
||||
// sie nicht auf OFFEN zuruecksetzen – IN ARBEIT ist mehr Information.
|
||||
expect(statusForIssueState(true, "DOING")).toBe("DOING");
|
||||
expect(statusForIssueState(true, "BLOCKED")).toBe("BLOCKED");
|
||||
expect(statusForIssueState(true, "TODO")).toBe("TODO");
|
||||
});
|
||||
|
||||
it("bildet den Rundlauf ab, so verlustbehaftet wie er ist", () => {
|
||||
// IN ARBEIT geht nach draussen als "offen". Kommt es zurueck, bleibt es
|
||||
// IN ARBEIT – der Zustand ueberlebt also, solange niemand das Issue
|
||||
// schliesst. Nach dem Schliessen und Wiederoeffnen ist er weg, und das
|
||||
// ist die bewusst hingenommene Grenze.
|
||||
const hin = issueShouldBeOpen("DOING");
|
||||
expect(statusForIssueState(hin, "DOING")).toBe("DOING");
|
||||
expect(statusForIssueState(true, statusForIssueState(false, "DOING"))).toBe("TODO");
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,192 @@
|
||||
import type { TaskStatus } from "@prisma/client";
|
||||
import { recordActivity, shorten } from "@/lib/activity";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { clientForConnection } from "@/lib/git";
|
||||
import type { GitClient, RepoRef } from "@/lib/git/types";
|
||||
import { nextPosition, refreshDerivedProgress, spawnRecurrence } from "@/lib/tasks";
|
||||
|
||||
/**
|
||||
* Die Bruecke zwischen Nebula-Aufgabe und Git-Issue.
|
||||
*
|
||||
* Die Zustaende passen nicht aufeinander und das bleibt so: Nebula kennt
|
||||
* OFFEN, IN ARBEIT, BLOCKIERT und ERLEDIGT, ein Issue nur offen oder
|
||||
* geschlossen. Nach aussen geht deshalb nur die Grenze zwischen "erledigt"
|
||||
* und "nicht erledigt"; ein Rundlauf verliert IN ARBEIT und BLOCKIERT.
|
||||
*
|
||||
* Die Alternative waeren Labels wie "nebula:doing" – die wuerden den
|
||||
* Issue-Tracker aber mit Zustaenden fuellen, die dort niemand pflegt. Die
|
||||
* feine Abstufung bleibt in Nebula.
|
||||
*/
|
||||
|
||||
/** Ist der Aufgabenzustand einer, bei dem das Issue offen sein soll? */
|
||||
export function issueShouldBeOpen(status: TaskStatus): boolean {
|
||||
return status !== "DONE";
|
||||
}
|
||||
|
||||
/** Der Aufgabenzustand, der zu einem Issue-Zustand passt. */
|
||||
export function statusForIssueState(open: boolean, current: TaskStatus): TaskStatus {
|
||||
if (open) {
|
||||
// Ein wieder geoeffnetes Issue macht aus ERLEDIGT wieder OFFEN. Stand
|
||||
// die Aufgabe ohnehin nicht auf ERLEDIGT, bleibt ihr feinerer Zustand
|
||||
// stehen – IN ARBEIT ist mehr Information als OFFEN.
|
||||
return current === "DONE" ? "TODO" : current;
|
||||
}
|
||||
return "DONE";
|
||||
}
|
||||
|
||||
/**
|
||||
* Traegt den Zustand einer Aufgabe an ihrem Issue nach.
|
||||
*
|
||||
* Bewusst fehlertolerant: schlaegt der Aufruf fehl, ist die Aufgabe in
|
||||
* Nebula trotzdem umgezogen. Ein nicht erreichbares Git-System darf das
|
||||
* Abhaken nicht verhindern – der naechste Wechsel versucht es erneut.
|
||||
*
|
||||
* Gibt zurueck, ob es geklappt hat; null heisst "nichts zu tun".
|
||||
*/
|
||||
export async function mirrorStatusToIssue(
|
||||
taskId: string,
|
||||
status: TaskStatus,
|
||||
): Promise<boolean | null> {
|
||||
const task = await prisma.task.findUnique({
|
||||
where: { id: taskId },
|
||||
select: { sourceIssue: true, sourceRepositoryId: true },
|
||||
});
|
||||
if (!task?.sourceIssue || !task.sourceRepositoryId) return null;
|
||||
|
||||
const repository = await prisma.repository.findUnique({
|
||||
where: { id: task.sourceRepositoryId },
|
||||
include: { connection: true },
|
||||
});
|
||||
if (!repository?.connection || !repository.repoOwner || !repository.repoName) return null;
|
||||
|
||||
try {
|
||||
const client = clientForConnection(repository.connection);
|
||||
await client.setIssueState(
|
||||
{ owner: repository.repoOwner, name: repository.repoName },
|
||||
task.sourceIssue,
|
||||
issueShouldBeOpen(status),
|
||||
);
|
||||
return true;
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Hakt eine Aufgabe ab, weil ihr Issue geschlossen wurde.
|
||||
*
|
||||
* Bewusst an einer Stelle fuer beide Wege – Webhook und Abgleich. Vorher
|
||||
* setzte der Webhook nur den Status und liess dabei aus, was die Oberflaeche
|
||||
* tut: die naechste Fassung einer wiederkehrenden Aufgabe anlegen und den
|
||||
* Vorgang in den Verlauf schreiben.
|
||||
*
|
||||
* Gibt false zurueck, wenn nichts zu tun war (Aufgabe fehlt oder ist schon
|
||||
* erledigt) – der Aufrufer kann daran zaehlen, was er bewirkt hat.
|
||||
*/
|
||||
export async function completeTaskFromIssue(
|
||||
taskId: string,
|
||||
herkunft: "webhook" | "abgleich",
|
||||
): Promise<boolean> {
|
||||
const task = await prisma.task.findUnique({
|
||||
where: { id: taskId },
|
||||
select: { id: true, title: true, status: true, projectId: true, sourceIssue: true },
|
||||
});
|
||||
if (!task || task.status === "DONE") return false;
|
||||
|
||||
await prisma.task.update({
|
||||
where: { id: task.id },
|
||||
data: {
|
||||
status: "DONE",
|
||||
doneAt: new Date(),
|
||||
position: await nextPosition(task.projectId, "DONE"),
|
||||
},
|
||||
});
|
||||
|
||||
// Wie beim Abhaken von Hand: eine wiederkehrende Aufgabe erzeugt ihre
|
||||
// naechste Fassung.
|
||||
const folge = await spawnRecurrence(task.id);
|
||||
await refreshDerivedProgress(task.projectId);
|
||||
|
||||
await recordActivity({
|
||||
projectId: task.projectId,
|
||||
// Kein userId: das hat nicht ein Mensch in Nebula getan, sondern das
|
||||
// Git-System gemeldet.
|
||||
kind: "TASK_MOVED",
|
||||
summary:
|
||||
`Issue #${task.sourceIssue} geschlossen → „${shorten(task.title, 40)}“ erledigt` +
|
||||
(herkunft === "abgleich" ? " (beim Abgleich bemerkt)" : "") +
|
||||
(folge ? ", nächste angelegt" : ""),
|
||||
meta: { taskId: task.id, issue: task.sourceIssue, source: herkunft },
|
||||
});
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/** Wie viele Issues ein Abgleich hoechstens einzeln nachfragt. */
|
||||
const MAX_NACHFRAGEN = 25;
|
||||
|
||||
/**
|
||||
* Gleicht beim Abgleich die verknuepften Issues ab: was in Git geschlossen
|
||||
* ist, wird in Nebula abgehakt.
|
||||
*
|
||||
* Warum zusaetzlich zum Webhook: der Webhook wirkt sofort, setzt aber voraus,
|
||||
* dass die Instanz von aussen erreichbar ist und der Haken eingetragen wurde.
|
||||
* Ist er das nicht – oder faellt er einmal aus –, bliebe der Rueckweg sonst
|
||||
* ganz aus. Hier kommt er verzoegert, aber verlaesslich.
|
||||
*
|
||||
* **Nur abhaken, nie zuruecknehmen.** Der Abgleich sieht Zustaende, keine
|
||||
* Ereignisse. Ein offenes Issue kann auch bedeuten, dass das Schliessen von
|
||||
* Nebula aus fehlgeschlagen ist – dann wuerde ein symmetrischer Abgleich eine
|
||||
* bewusst erledigte Aufgabe wieder aufmachen. Das Zuruecknehmen bleibt dem
|
||||
* Webhook vorbehalten, der ein echtes "reopened" sieht.
|
||||
*
|
||||
* Fehler werden geschluckt: ein nicht erreichbares Issue darf den Abgleich
|
||||
* des Repositories nicht scheitern lassen.
|
||||
*/
|
||||
export async function reconcileLinkedIssues(
|
||||
repositoryId: string,
|
||||
client: GitClient,
|
||||
ref: RepoRef,
|
||||
/** Nummern, die der Snapshot gerade als offen gemeldet hat. */
|
||||
offeneNummern: number[] = [],
|
||||
): Promise<number> {
|
||||
const offen = new Set(offeneNummern);
|
||||
|
||||
const kandidaten = await prisma.task.findMany({
|
||||
where: {
|
||||
sourceRepositoryId: repositoryId,
|
||||
sourceIssue: { not: null },
|
||||
status: { not: "DONE" },
|
||||
},
|
||||
select: { id: true, sourceIssue: true },
|
||||
orderBy: { createdAt: "asc" },
|
||||
});
|
||||
|
||||
let abgehakt = 0;
|
||||
let nachfragen = 0;
|
||||
|
||||
for (const task of kandidaten) {
|
||||
const nummer = task.sourceIssue;
|
||||
if (nummer === null) continue;
|
||||
|
||||
// Steht die Nummer in der Liste der offenen Issues, ist nichts zu tun –
|
||||
// und der Aufruf gespart. Umgekehrt gilt das nicht: die Liste ist
|
||||
// gedeckelt, aus dem Fehlen folgt also nichts.
|
||||
if (offen.has(nummer)) continue;
|
||||
|
||||
if (nachfragen >= MAX_NACHFRAGEN) break;
|
||||
nachfragen += 1;
|
||||
|
||||
try {
|
||||
const zustand = await client.getIssueState(ref, nummer);
|
||||
// null heisst "gibt es nicht mehr" – geloescht ist nicht erledigt,
|
||||
// also bleibt die Aufgabe stehen.
|
||||
if (zustand !== "closed") continue;
|
||||
if (await completeTaskFromIssue(task.id, "abgleich")) abgehakt += 1;
|
||||
} catch {
|
||||
// Nichts erreichbar, nichts geaendert – der naechste Lauf versucht es.
|
||||
}
|
||||
}
|
||||
|
||||
return abgehakt;
|
||||
}
|
||||
@@ -0,0 +1,137 @@
|
||||
import { createHmac } from "node:crypto";
|
||||
import { describe, expect, it } from "vitest";
|
||||
import { parseEvent, verifySignature } from "./verify";
|
||||
|
||||
const GEHEIM = "ein-geheimnis-das-lang-genug-ist";
|
||||
const RUMPF = JSON.stringify({ action: "closed", issue: { number: 12 } });
|
||||
|
||||
function signiere(secret: string, body: string): string {
|
||||
return createHmac("sha256", secret).update(body, "utf8").digest("hex");
|
||||
}
|
||||
|
||||
function kopf(eintraege: Record<string, string>): Headers {
|
||||
return new Headers(eintraege);
|
||||
}
|
||||
|
||||
describe("verifySignature – GitHub", () => {
|
||||
it("nimmt die richtige Signatur an", () => {
|
||||
const headers = kopf({ "x-hub-signature-256": `sha256=${signiere(GEHEIM, RUMPF)}` });
|
||||
expect(verifySignature("GITHUB", GEHEIM, RUMPF, headers)).toEqual({ ok: true });
|
||||
});
|
||||
|
||||
it("weist eine fremde Signatur ab", () => {
|
||||
const headers = kopf({ "x-hub-signature-256": `sha256=${signiere("anderes", RUMPF)}` });
|
||||
expect(verifySignature("GITHUB", GEHEIM, RUMPF, headers)).toEqual({
|
||||
ok: false,
|
||||
reason: "mismatch",
|
||||
});
|
||||
});
|
||||
|
||||
it("weist ab, wenn der Rumpf veraendert wurde", () => {
|
||||
// Das ist der eigentliche Zweck: die Signatur haengt am Inhalt.
|
||||
const headers = kopf({ "x-hub-signature-256": `sha256=${signiere(GEHEIM, RUMPF)}` });
|
||||
const veraendert = JSON.stringify({ action: "closed", issue: { number: 99 } });
|
||||
expect(verifySignature("GITHUB", GEHEIM, veraendert, headers).ok).toBe(false);
|
||||
});
|
||||
|
||||
it("weist ab, wenn gar keine Signatur mitkommt", () => {
|
||||
expect(verifySignature("GITHUB", GEHEIM, RUMPF, kopf({}))).toEqual({
|
||||
ok: false,
|
||||
reason: "missing",
|
||||
});
|
||||
});
|
||||
|
||||
it("laesst sich nicht mit dem blossen Praefix taeuschen", () => {
|
||||
expect(verifySignature("GITHUB", GEHEIM, RUMPF, kopf({ "x-hub-signature-256": "sha256=" })).ok).toBe(
|
||||
false,
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe("verifySignature – Gitea", () => {
|
||||
it("nimmt die Signatur ohne Praefix an", () => {
|
||||
const headers = kopf({ "x-gitea-signature": signiere(GEHEIM, RUMPF) });
|
||||
expect(verifySignature("GITEA", GEHEIM, RUMPF, headers)).toEqual({ ok: true });
|
||||
});
|
||||
|
||||
it("nimmt ersatzweise das GitHub-Format an", () => {
|
||||
// Aeltere Gitea-Fassungen senden nur X-Hub-Signature-256.
|
||||
const headers = kopf({ "x-hub-signature-256": `sha256=${signiere(GEHEIM, RUMPF)}` });
|
||||
expect(verifySignature("GITEA", GEHEIM, RUMPF, headers)).toEqual({ ok: true });
|
||||
});
|
||||
|
||||
it("weist eine falsche Signatur ab", () => {
|
||||
const headers = kopf({ "x-gitea-signature": signiere("anderes", RUMPF) });
|
||||
expect(verifySignature("GITEA", GEHEIM, RUMPF, headers).ok).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe("verifySignature – GitLab", () => {
|
||||
it("vergleicht den Token im Klartext", () => {
|
||||
expect(verifySignature("GITLAB", GEHEIM, RUMPF, kopf({ "x-gitlab-token": GEHEIM }))).toEqual({
|
||||
ok: true,
|
||||
});
|
||||
});
|
||||
|
||||
it("weist einen falschen Token ab", () => {
|
||||
expect(
|
||||
verifySignature("GITLAB", GEHEIM, RUMPF, kopf({ "x-gitlab-token": "falsch" })).ok,
|
||||
).toBe(false);
|
||||
});
|
||||
|
||||
it("weist ab, wenn der Token fehlt", () => {
|
||||
expect(verifySignature("GITLAB", GEHEIM, RUMPF, kopf({}))).toEqual({
|
||||
ok: false,
|
||||
reason: "missing",
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("parseEvent", () => {
|
||||
it("erkennt einen Push", () => {
|
||||
expect(parseEvent("GITHUB", "push", {})).toEqual({ kind: "push" });
|
||||
});
|
||||
|
||||
it("erkennt ein geschlossenes Issue bei GitHub und Gitea", () => {
|
||||
const nutzlast = { action: "closed", issue: { number: 12 } };
|
||||
expect(parseEvent("GITHUB", "issues", nutzlast)).toEqual({
|
||||
kind: "issue",
|
||||
number: 12,
|
||||
open: false,
|
||||
});
|
||||
expect(parseEvent("GITEA", "issues", nutzlast)).toEqual({
|
||||
kind: "issue",
|
||||
number: 12,
|
||||
open: false,
|
||||
});
|
||||
});
|
||||
|
||||
it("erkennt ein wieder geoeffnetes Issue", () => {
|
||||
expect(parseEvent("GITHUB", "issues", { action: "reopened", issue: { number: 7 } })).toEqual({
|
||||
kind: "issue",
|
||||
number: 7,
|
||||
open: true,
|
||||
});
|
||||
});
|
||||
|
||||
it("nimmt bei GitLab die projektinterne Nummer", () => {
|
||||
// "iid" ist die Nummer aus der Oberflaeche; "id" waere instanzweit.
|
||||
const ereignis = parseEvent("GITLAB", "Issue Hook", {
|
||||
object_kind: "issue",
|
||||
object_attributes: { iid: 5, state: "closed" },
|
||||
});
|
||||
expect(ereignis).toEqual({ kind: "issue", number: 5, open: false });
|
||||
});
|
||||
|
||||
it("laesst Unbekanntes liegen, statt zu scheitern", () => {
|
||||
expect(parseEvent("GITHUB", "issue_comment", {}).kind).toBe("ignored");
|
||||
expect(parseEvent("GITHUB", "issues", { action: "labeled", issue: { number: 1 } }).kind).toBe(
|
||||
"ignored",
|
||||
);
|
||||
expect(parseEvent("GITHUB", null, null).kind).toBe("ignored");
|
||||
});
|
||||
|
||||
it("laesst ein Issue ohne Nummer liegen", () => {
|
||||
expect(parseEvent("GITHUB", "issues", { action: "closed", issue: {} }).kind).toBe("ignored");
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,139 @@
|
||||
import { createHmac, timingSafeEqual } from "node:crypto";
|
||||
import type { GitProvider } from "@prisma/client";
|
||||
|
||||
/**
|
||||
* Pruefung eingehender Webhooks.
|
||||
*
|
||||
* Der Endpunkt ist die einzige Stelle der Anwendung, die ohne Anmeldung
|
||||
* schreibend wirkt – deshalb steht die Pruefung hier fuer sich, ohne
|
||||
* Datenbank und ohne Netz, und ist damit vollstaendig testbar.
|
||||
*
|
||||
* Die drei Systeme machen es unterschiedlich:
|
||||
*
|
||||
* GitHub X-Hub-Signature-256: "sha256=<hex>", HMAC-SHA256 ueber den Rumpf
|
||||
* Gitea X-Gitea-Signature: "<hex>" ohne Praefix, sonst gleich
|
||||
* GitLab X-Gitlab-Token: das Geheimnis im Klartext, keine Signatur
|
||||
*
|
||||
* GitLabs Verfahren ist schwaecher – es beweist nur, dass der Absender das
|
||||
* Geheimnis kennt, nicht dass der Rumpf unveraendert ist. Mehr gibt die
|
||||
* Plattform nicht her; verglichen wird trotzdem zeitkonstant.
|
||||
*/
|
||||
|
||||
export type VerifyResult =
|
||||
| { ok: true }
|
||||
| { ok: false; reason: "missing" | "mismatch" | "unsupported" };
|
||||
|
||||
/** Vergleich ohne Laufzeitunterschied – ein Zeichenvergleich waere angreifbar. */
|
||||
function equals(a: string, b: string): boolean {
|
||||
const links = Buffer.from(a, "utf8");
|
||||
const rechts = Buffer.from(b, "utf8");
|
||||
// timingSafeEqual verlangt gleiche Laenge und wirft sonst. Die Laenge
|
||||
// selbst ist kein Geheimnis, der fruehe Ausstieg also unbedenklich.
|
||||
if (links.length !== rechts.length) return false;
|
||||
return timingSafeEqual(links, rechts);
|
||||
}
|
||||
|
||||
function hmacHex(secret: string, body: string): string {
|
||||
return createHmac("sha256", secret).update(body, "utf8").digest("hex");
|
||||
}
|
||||
|
||||
/**
|
||||
* Prueft die Signatur eines eingehenden Aufrufs.
|
||||
*
|
||||
* `body` muss der **rohe** Rumpf sein, genau wie er ankam. Ein durch
|
||||
* JSON.parse und JSON.stringify gedrehter Rumpf hat eine andere Signatur –
|
||||
* andere Reihenfolge, anderes Escaping, kein Leerraum.
|
||||
*/
|
||||
export function verifySignature(
|
||||
provider: GitProvider,
|
||||
secret: string,
|
||||
body: string,
|
||||
headers: Headers,
|
||||
): VerifyResult {
|
||||
switch (provider) {
|
||||
case "GITHUB": {
|
||||
const gesendet = headers.get("x-hub-signature-256");
|
||||
if (!gesendet) return { ok: false, reason: "missing" };
|
||||
const erwartet = `sha256=${hmacHex(secret, body)}`;
|
||||
return equals(gesendet, erwartet) ? { ok: true } : { ok: false, reason: "mismatch" };
|
||||
}
|
||||
|
||||
case "GITEA": {
|
||||
// Gitea schickt die Signatur ohne Praefix. Aeltere Fassungen senden
|
||||
// zusaetzlich X-Hub-Signature-256 im GitHub-Format – beides gilt.
|
||||
const gitea = headers.get("x-gitea-signature");
|
||||
if (gitea) {
|
||||
return equals(gitea, hmacHex(secret, body))
|
||||
? { ok: true }
|
||||
: { ok: false, reason: "mismatch" };
|
||||
}
|
||||
const hub = headers.get("x-hub-signature-256");
|
||||
if (hub) {
|
||||
return equals(hub, `sha256=${hmacHex(secret, body)}`)
|
||||
? { ok: true }
|
||||
: { ok: false, reason: "mismatch" };
|
||||
}
|
||||
return { ok: false, reason: "missing" };
|
||||
}
|
||||
|
||||
case "GITLAB": {
|
||||
const token = headers.get("x-gitlab-token");
|
||||
if (!token) return { ok: false, reason: "missing" };
|
||||
return equals(token, secret) ? { ok: true } : { ok: false, reason: "mismatch" };
|
||||
}
|
||||
|
||||
default:
|
||||
return { ok: false, reason: "unsupported" };
|
||||
}
|
||||
}
|
||||
|
||||
/** Welches Ereignis kam an – auf einen gemeinsamen Nenner gebracht. */
|
||||
export type WebhookEvent =
|
||||
| { kind: "push" }
|
||||
| { kind: "issue"; number: number; open: boolean }
|
||||
| { kind: "ignored"; name: string };
|
||||
|
||||
interface IssuePayload {
|
||||
action?: string;
|
||||
issue?: { number?: number; iid?: number; state?: string };
|
||||
object_attributes?: { iid?: number; action?: string; state?: string };
|
||||
object_kind?: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* Uebersetzt den Rumpf in ein Ereignis, das die Anwendung kennt.
|
||||
*
|
||||
* Bewusst grob: Nebula interessiert nur, ob ein Push kam (dann lohnt ein
|
||||
* Abgleich) und ob ein Issue geschlossen oder wieder geoeffnet wurde (dann
|
||||
* wandert die Aufgabe mit). Alles andere wird benannt und liegen gelassen.
|
||||
*/
|
||||
export function parseEvent(
|
||||
provider: GitProvider,
|
||||
eventName: string | null,
|
||||
payload: unknown,
|
||||
): WebhookEvent {
|
||||
const daten = (payload ?? {}) as IssuePayload;
|
||||
const name = (eventName ?? daten.object_kind ?? "").toLowerCase();
|
||||
|
||||
if (name === "push" || name === "push hook") return { kind: "push" };
|
||||
|
||||
if (provider === "GITLAB") {
|
||||
if (name !== "issue" && name !== "issue hook") return { kind: "ignored", name };
|
||||
const attrs = daten.object_attributes;
|
||||
const nummer = attrs?.iid;
|
||||
if (typeof nummer !== "number") return { kind: "ignored", name };
|
||||
// GitLab meldet den Zustand als "opened" oder "closed".
|
||||
const offen = attrs?.state !== "closed";
|
||||
return { kind: "issue", number: nummer, open: offen };
|
||||
}
|
||||
|
||||
// GitHub und Gitea nennen das Ereignis "issues" und legen die Tat in
|
||||
// "action" ab. Umbenennungen und Kommentare interessieren hier nicht.
|
||||
if (name !== "issues") return { kind: "ignored", name };
|
||||
const nummer = daten.issue?.number;
|
||||
if (typeof nummer !== "number") return { kind: "ignored", name };
|
||||
if (daten.action !== "closed" && daten.action !== "reopened" && daten.action !== "opened") {
|
||||
return { kind: "ignored", name: `issues.${daten.action ?? "?"}` };
|
||||
}
|
||||
return { kind: "issue", number: nummer, open: daten.action !== "closed" };
|
||||
}
|
||||
+25
-4
@@ -15,11 +15,27 @@ import { NextResponse, type NextRequest } from "next/server";
|
||||
*/
|
||||
|
||||
const SAFE_METHODS = new Set(["GET", "HEAD", "OPTIONS"]);
|
||||
const SESSION_COOKIE = "nebula_session";
|
||||
|
||||
/**
|
||||
* Beide moeglichen Namen des Sitzungscookies.
|
||||
*
|
||||
* Bei https traegt er den Praefix "__Host-", sonst nicht (der Praefix
|
||||
* verlangt zwingend Secure). Welcher gilt, entscheidet lib/config anhand
|
||||
* der APP_URL – hier im Edge-Runtime wird schlicht auf beide geschaut. Es
|
||||
* geht ohnehin nur um die grobe Vorpruefung; verbindlich entscheidet
|
||||
* requireUserPage bzw. requireUserApi.
|
||||
*/
|
||||
const SESSION_COOKIES = ["__Host-nebula_session", "nebula_session"];
|
||||
|
||||
/** Ohne Anmeldung erreichbar. */
|
||||
const PUBLIC_PATHS = ["/login", "/setup", "/register"];
|
||||
const PUBLIC_API_PREFIXES = ["/api/auth/"];
|
||||
/**
|
||||
* Eingehende Webhooks bringen kein Cookie mit – sie kommen von GitHub,
|
||||
* GitLab oder Gitea. Ausgewiesen wird sich dort mit einer Signatur ueber den
|
||||
* Rumpf, geprueft im Endpunkt selbst (lib/webhooks/verify). Ohne gueltiges
|
||||
* Geheimnis passiert nichts.
|
||||
*/
|
||||
const PUBLIC_API_PREFIXES = ["/api/auth/", "/api/webhooks/"];
|
||||
/**
|
||||
* Der Docker-Healthcheck hat kein Cookie. Manifest und Symbole braucht der
|
||||
* Browser, bevor sich jemand angemeldet hat – wuerden sie zur Anmeldeseite
|
||||
@@ -91,7 +107,12 @@ export function middleware(request: NextRequest) {
|
||||
const isDev = process.env.NODE_ENV === "development";
|
||||
|
||||
// ── 1. CSRF ────────────────────────────────────────────────
|
||||
if (!SAFE_METHODS.has(request.method) && !isSameOrigin(request)) {
|
||||
// Webhooks kommen von einem fremden Server und koennen keinen passenden
|
||||
// Origin mitbringen. Die Herkunftspruefung schuetzt gegen den Browser
|
||||
// eines angemeldeten Nutzers – hier gibt es keinen, und ausgewiesen wird
|
||||
// sich stattdessen mit der Signatur ueber den Rumpf.
|
||||
const istWebhook = pathname.startsWith("/api/webhooks/");
|
||||
if (!istWebhook && !SAFE_METHODS.has(request.method) && !isSameOrigin(request)) {
|
||||
return NextResponse.json(
|
||||
{ error: "Anfrage von fremdem Ursprung abgelehnt." },
|
||||
{ status: 403 },
|
||||
@@ -99,7 +120,7 @@ export function middleware(request: NextRequest) {
|
||||
}
|
||||
|
||||
// ── 2. Zugangsschranke ─────────────────────────────────────
|
||||
const hasSession = Boolean(request.cookies.get(SESSION_COOKIE)?.value);
|
||||
const hasSession = SESSION_COOKIES.some((name) => Boolean(request.cookies.get(name)?.value));
|
||||
if (!hasSession && !isPublicPath(pathname)) {
|
||||
if (pathname.startsWith("/api/")) {
|
||||
return NextResponse.json({ error: "Nicht angemeldet." }, { status: 401 });
|
||||
|
||||
+10
-3
@@ -40,8 +40,14 @@ export interface ConnectionWithCount extends ConnectionSafe {
|
||||
_count?: { repositories: number };
|
||||
}
|
||||
|
||||
/** Ein Repository samt Verbindung und zuletzt geholtem Stand. */
|
||||
export interface RepositoryWithSnapshot extends Repository {
|
||||
/**
|
||||
* Ein Repository samt Verbindung und zuletzt geholtem Stand.
|
||||
*
|
||||
* Ohne webhookSecret: das Geheimnis verlaesst den Server nicht – siehe
|
||||
* repositorySafeSelect. Ob einer eingerichtet ist, reicht die Projektseite
|
||||
* getrennt durch.
|
||||
*/
|
||||
export interface RepositoryWithSnapshot extends Omit<Repository, "webhookSecret"> {
|
||||
connection: ConnectionSafe | null;
|
||||
snapshot: RepoSnapshot | null;
|
||||
}
|
||||
@@ -87,7 +93,8 @@ export interface TaskOverviewItem {
|
||||
dueDate: string | null;
|
||||
labels: string[];
|
||||
recurrence: Recurrence | null;
|
||||
/** Gesetzt, wenn die Aufgabe aus einem Git-Issue stammt. */
|
||||
/** Gesetzt, wenn die Aufgabe an einem Git-Issue haengt. */
|
||||
sourceIssue: number | null;
|
||||
sourceUrl: string | null;
|
||||
bucket: DueBucket;
|
||||
project: { id: string; name: string; accent: string; status: ProjectStatus };
|
||||
|
||||
Reference in New Issue
Block a user