feat(v5): Etappe W-0 — das Geruest steht

Electron 44 + TypeScript, drei Prozesse (haupt / kern als utilityProcess / fenster mit React), Nachrichten-Schema mit Pruef-Funktionen, node:sqlite als einzige Datenbank-Stelle (kern/speicher/db.ts, § 6.7), Prozess-Leine im Haupt (Job Object aus beweise/leine.js — Begruendung fuer den Ort im Dateikopf), MessagePort direkt Fenster<->Kern, Einzelinstanz-Sperre, Kern-Neustart-Wache, strikte CSP im gebauten Fenster. Wächter-Tests nach § 4.3: koffi nur an zwei benannten Orten (R1), kein leerer catch und kein catch-mit-Leerwert (R2/R4), kein HTTP-Server (§ 4.1), node:sqlite nur in db.ts (§ 6.7). Dazu Datenbank- und Schema-Tests: 18/18 gruen, Typpruefung in drei Kontexten. Der W-0-Beweis (npm run smoke, echtes Programm): SMOKE: OK — fenster=geladen kern=pid:13676,node:24.18.1 datenbank=ok leine=gesetzt pong=ok version=5.0.0-w0 Nachgemessen ausserdem: taskkill /F auf den Haupt-Prozess (ohne /T, der Absturz-Fall aus rc10) — der Kern stirbt mit. Bau-Fallen dokumentiert (BAUEN.md): npm 11 blockt Electrons Install-Skript (§ 3.5), plugin-react 6 verlangt Vite 8 (deshalb 5.2), TypeScript bewusst auf 5.9.3 gepinnt statt tsgo 7. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-08-30 16:53:30 +02:00
parent 564bd17f84
commit c539e65cd2
27 changed files with 5207 additions and 0 deletions
@@ -0,0 +1,171 @@
+// Rippy v5 — Haupt-Prozess (KONZEPT-WINDOWS.md § 4.1).
+// Ablauf: Einzelinstanz-Sperre → Prozess-Leine → Kern starten → Fenster
+// öffnen → Fenster und Kern über einen MessagePort verdrahten.
+//
+// Smoke-Modus (`electron . --smoke`): beweist das W-0-Fertigkriterium
+// („Ein Fenster geht auf, der Kern läuft") maschinell — alle drei Prozesse,
+// beide IPC-Wege und die Datenbank — und endet mit Code 0 (grün) oder 2.
+// RIPPY_SMOKE_BILD=<pfad.png> legt zusätzlich einen Screenshot ab.
+import { app, ipcMain, type BrowserWindow } from 'electron'
+import { writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import type { HauptStatus, KernNachricht } from '../gemeinsam/nachrichten'
+import { fensterErstellen } from './fenster'
+import { KernVerwaltung } from './kernstart'
+import { leineSetzen, type LeineStatus } from './leine'
+
+const smokeModus = process.argv.includes('--smoke')
+
+// Der Smoke-Lauf fasst das echte Profil nicht an — er hinterlässt nichts.
+if (smokeModus) {
+  app.setPath('userData', join(app.getPath('temp'), 'rippy-smoke'))
+}
+
+// Nur EIN Rippy je Benutzer (§ 4.2: Einzelinstanz-Sperre). Die zweite
+// Instanz beendet sich; die erste holt ihr Fenster nach vorn.
+if (!app.requestSingleInstanceLock()) {
+  app.exit(0)
+} else {
+  start()
+}
+
+function start(): void {
+  // Die Leine kommt VOR dem ersten Kindprozess — Mitgliedschaft in der
+  // Arbeitsgruppe wird nur beim Start eines Kindes vererbt (§ 3.3).
+  const leine: LeineStatus = leineSetzen()
+  if (!leine.ok) {
+    // R4: laut, nicht still — zusätzlich steht es im Fenster-Status.
+    console.error(`[haupt] Prozess-Leine NICHT gesetzt: ${leine.fehler}`)
+  }
+
+  let fenster: BrowserWindow | null = null
+  let letzteKernNachricht: KernNachricht | null = null
+
+  const smoke = {
+    fenster: false,
+    kern: false,
+    datenbank: false,
+    leine: leine.ok,
+    pong: false,
+  }
+
+  const kernVerwaltung = new KernVerwaltung(
+    join(app.getPath('userData'), 'rippy.db'),
+    (nachricht) => {
+      letzteKernNachricht = nachricht
+      if (nachricht.art === 'kern-bereit') {
+        smoke.kern = true
+        smoke.datenbank = nachricht.datenbank.ok
+        if (!nachricht.datenbank.ok) {
+          console.error(`[haupt] Kern meldet Datenbank-Fehler: ${nachricht.datenbank.fehler}`)
+        }
+        statusSenden()
+        smokePruefen()
+      }
+    },
+    () => statusSenden(),
+  )
+
+  function statusSenden(): void {
+    if (fenster === null || fenster.isDestroyed()) return
+    const status: HauptStatus = {
+      version: app.getVersion(),
+      leine,
+      kern: kernVerwaltung.zustand(),
+    }
+    fenster.webContents.send('haupt-status', status)
+  }
+
+  // Kurze Rückmeldungen aus dem Fenster (Brücke: rippy.melden). Im
+  // Smoke-Lauf ist 'kern-pong' der Beweis, dass der MessagePort
+  // Fenster ↔ Kern in BEIDE Richtungen trägt.
+  ipcMain.on('fenster-meldung', (_ereignis, art: unknown) => {
+    if (art === 'kern-pong') {
+      smoke.pong = true
+      smokePruefen()
+    }
+  })
+
+  app.on('second-instance', () => {
+    if (fenster !== null && !fenster.isDestroyed()) {
+      if (fenster.isMinimized()) fenster.restore()
+      fenster.focus()
+    }
+  })
+
+  // W-0: Fenster zu = Rippy zu. Erst W-5 bringt das Tray-Symbol — dann lebt
+  // Rippy nach dem Schließen im Hintergrund weiter (§ 4.1, Punkt 3).
+  app.on('window-all-closed', () => {
+    app.quit()
+  })
+
+  app.on('before-quit', () => {
+    kernVerwaltung.beenden()
+  })
+
+  void app.whenReady().then(() => {
+    kernVerwaltung.starten()
+    fenster = fensterErstellen()
+    fenster.webContents.on('did-finish-load', () => {
+      smoke.fenster = true
+      // Verdrahtung NACH dem Laden: Die Seite lauscht erst dann auf den Port.
+      kernVerwaltung.fensterVerbinden(fenster!.webContents)
+      statusSenden()
+      smokePruefen()
+    })
+  })
+
+  let smokeAbgeschlossen = false
+
+  function smokePruefen(): void {
+    if (!smokeModus || smokeAbgeschlossen) return
+    const fehlt = Object.entries(smoke)
+      .filter(([, wert]) => !wert)
+      .map(([name]) => name)
+    if (fehlt.length > 0) return
+    smokeAbgeschlossen = true
+    void smokeAbschliessen()
+  }
+
+  async function smokeAbschliessen(): Promise<void> {
+    const bildPfad = process.env['RIPPY_SMOKE_BILD']
+    if (bildPfad !== undefined && bildPfad.length > 0 && fenster !== null) {
+      try {
+        // Der Pong kommt schneller, als der Compositor das erste Bild malt —
+        // ein sofortiges capturePage lieferte hier »UnknownVizError«
+        // (gemessen 30.08.2026). Kurz warten, bis wirklich gemalt ist.
+        await new Promise((fertig) => setTimeout(fertig, 750))
+        const bild = await fenster.webContents.capturePage()
+        await writeFile(bildPfad, bild.toPNG())
+        console.log(`SMOKE: Bild abgelegt unter ${bildPfad}`)
+      } catch (fehler) {
+        console.error(`SMOKE: Bild fehlgeschlagen: ${String(fehler)}`)
+      }
+    }
+    const kern = letzteKernNachricht
+    const kernInfo =
+      kern !== null && kern.art === 'kern-bereit'
+        ? `kern=pid:${kern.pid},node:${kern.nodeVersion}`
+        : 'kern=?'
+    console.log(
+      `SMOKE: OK — fenster=geladen ${kernInfo} datenbank=ok leine=gesetzt pong=ok version=${app.getVersion()}`,
+    )
+    // app.exit() überspringt before-quit — den Kern deshalb hier gewollt
+    // beenden, sonst deutet der exit-Wächter das als Absturz und startet neu.
+    kernVerwaltung.beenden()
+    setTimeout(() => app.exit(0), 100)
+  }
+
+  if (smokeModus) {
+    setTimeout(() => {
+      if (smokeAbgeschlossen) return
+      smokeAbgeschlossen = true
+      const fehlt = Object.entries(smoke)
+        .filter(([, wert]) => !wert)
+        .map(([name]) => name)
+      console.error(`SMOKE: FEHLGESCHLAGEN — es fehlt: ${fehlt.join(', ')}`)
+      kernVerwaltung.beenden()
+      setTimeout(() => app.exit(2), 100)
+    }, 25_000)
+  }
+}