hmgr 0.0.3 → 0.0.5

package/dist/gui/icons.js

@@ -0,0 +1,114 @@
+// Quellen-Icon im Main-Prozess (E60): Besitzer-Avatar bei GitHub/Gitea, sonst Favicon, sonst
+// generisch. Lädt nur hier (nie im Renderer, contextIsolation lässt dort ohnehin kein fetch mit
+// Netzzugriff zu, das hier ist reine Main-Prozess-Politik), cached als data-URL auf Platte
+// unterhalb von HMGR_HOME (Aufrufer reicht das Verzeichnis rein), damit Tests und der Smoke-Test
+// nie ein echtes Verzeichnis anfassen. Ein Fehlschlag wird mitgecacht, aber nur für einen Tag: ein
+// Treffer gilt für immer, ein Fehlschlag verfällt, sonst bliebe es bei generischen Symbolen für
+// jeden, der beim ersten Start ohne Netz war. „lokal" und jede unbekannte Adresse ergeben sofort null.
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { urlOrt } from "../kern/quelle-ort.js";
+const STANDARD_TIMEOUT_MS = 5000;
+/**
+ * Ein Fehlschlag hält einen Tag, ein Treffer hält für immer. Ohne Verfall bekäme jeder, der beim
+ * ersten Start offline war, dauerhaft nur generische Symbole — der Cache soll das Netz schonen,
+ * nicht ein einmaliges „gerade kein Netz" festschreiben.
+ */
+const FEHLSCHLAG_HALTBARKEIT_MS = 24 * 60 * 60 * 1000;
+/**
+ * Obergrenze für ein Icon. Ein Avatar oder Favicon ist ein paar Kilobyte groß; alles darüber ist
+ * kein Symbol mehr und hätte als data-URL nichts im Cache und in der Ansicht verloren.
+ */
+const MAX_ICON_BYTES = 512 * 1024;
+/**
+ * Kandidaten-URLs für den Besitzer-Avatar, in Versuchsreihenfolge (F35): GitHub liefert den Avatar
+ * über einen eigenen Pfad, jeder andere http(s)-Host bekommt zuerst den mutmaßlichen Avatar-Pfad
+ * versucht (das bedient auch Gitea), dann sein Favicon.
+ */
+export function iconKandidaten(ort) {
+    if (ort.host === 'github.com')
+        return [`https://github.com/${ort.besitzer}.png?size=40`];
+    return [`https://${ort.host}/${ort.besitzer}.png`, `https://${ort.host}/favicon.ico`];
+}
+function cacheDateiname(schluessel) {
+    return `${createHash('sha256').update(schluessel).digest('hex')}.txt`;
+}
+/**
+ * Die Zeitüberschreitung umfasst auch das Lesen des Rumpfs, nicht nur den Kopf: ein Server, der die
+ * Kopfzeilen sofort schickt und dann tröpfelt, würde den Aufruf sonst unbegrenzt hängen lassen.
+ * Deshalb läuft die ganze Arbeit unter demselben Signal, der Wecker fällt erst danach.
+ */
+async function mitTimeout(arbeit, timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await arbeit(controller.signal);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function alsDataUrl(antwort) {
+    if (!antwort.ok)
+        return undefined;
+    const typ = antwort.headers.get('content-type') ?? '';
+    if (!typ.startsWith('image/'))
+        return undefined;
+    const angekuendigt = Number(antwort.headers.get('content-length'));
+    if (Number.isFinite(angekuendigt) && angekuendigt > MAX_ICON_BYTES)
+        return undefined;
+    const puffer = Buffer.from(await antwort.arrayBuffer());
+    if (puffer.length === 0 || puffer.length > MAX_ICON_BYTES)
+        return undefined;
+    return `data:${typ.split(';')[0]};base64,${puffer.toString('base64')}`;
+}
+/**
+ * Was im Cache steht: eine data-URL (Treffer, gilt immer), oder ein Fehlschlag (leere Datei), der
+ * nur bis zu seiner Haltbarkeit gilt. Fehlt beides, muss abgefragt werden.
+ */
+async function ausCache(cachePfad) {
+    const inhalt = await readFile(cachePfad, 'utf8').catch(() => undefined);
+    if (inhalt === undefined)
+        return undefined;
+    if (inhalt.length > 0)
+        return { wert: inhalt };
+    const info = await stat(cachePfad).catch(() => undefined);
+    if (info && Date.now() - info.mtimeMs < FEHLSCHLAG_HALTBARKEIT_MS)
+        return { wert: null };
+    return undefined;
+}
+/**
+ * Icon einer Quelle als data-URL, oder null (lokale Quelle, unlesbare Adresse oder jeder
+ * Fehlschlag: Zeitüberschreitung, Netzfehler, kein Bild). Das Ergebnis – auch ein Fehlschlag –
+ * landet auf Platte, ein zweiter Aufruf für denselben Host/Besitzer fragt nicht erneut ab; ein
+ * gecachter Fehlschlag verfällt nach einem Tag und wird dann erneut versucht.
+ */
+export async function iconFuerQuelle(quelle, optionen) {
+    if (quelle.art === 'lokal')
+        return null;
+    const ort = urlOrt(quelle.url);
+    if (!ort || ort.host === 'local')
+        return null;
+    const holen = optionen.fetch ?? ((url, init) => fetch(url, init));
+    const timeoutMs = optionen.timeoutMs ?? STANDARD_TIMEOUT_MS;
+    const schluessel = `${ort.host}/${ort.besitzer}`;
+    const cachePfad = path.join(optionen.cacheVerzeichnis, cacheDateiname(schluessel));
+    const cached = await ausCache(cachePfad);
+    if (cached !== undefined)
+        return cached.wert;
+    let ergebnis;
+    for (const url of iconKandidaten(ort)) {
+        try {
+            ergebnis = await mitTimeout(async (signal) => alsDataUrl(await holen(url, { signal })), timeoutMs);
+        }
+        catch {
+            ergebnis = undefined;
+        }
+        if (ergebnis)
+            break;
+    }
+    await mkdir(optionen.cacheVerzeichnis, { recursive: true }).catch(() => undefined);
+    await writeFile(cachePfad, ergebnis ?? '', 'utf8').catch(() => undefined);
+    return ergebnis ?? null;
+}

package/dist/gui/main.js

@@ -0,0 +1,481 @@
+// hmgr-GUI, Electron-Main (E40). Baut dieselben Anwendungsfälle wie die CLI (src/cli/main.ts),
+// registriert IPC-Handler für den Renderer und implementiert den Rückfrage-Port als Dialog im
+// Fenster. Kein zweiter Prozess: der Kern läuft direkt im Main-Prozess, die GUI ist ein zweiter
+// Kompositions-Einstieg neben der CLI (ARCHITEKTUR.md „Eingang").
+import { app, BrowserWindow, dialog, ipcMain, shell } from 'electron';
+import path from 'node:path';
+import os from 'node:os';
+import { randomUUID } from 'node:crypto';
+import { stat } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { bauen, umgebungLesen } from "../cli/main.js";
+import { quelleAlsText, quelleAusText } from "../adapter/quelle-text.js";
+import { quelleName, quelleSchluessel } from "../kern/modell.js";
+import { iconFuerQuelle } from "./icons.js";
+import { entscheideOeffnen } from "./oeffnen.js";
+const hierVerzeichnis = path.dirname(fileURLToPath(import.meta.url));
+const smoketest = process.env.HMGR_GUI_SMOKETEST === '1';
+const umgebung = umgebungLesen();
+/** Cache der Quellen-Icons (E60), unterhalb von HMGR_HOME wie der Zustand: Tests/Smoke fassen so
+    nie ein echtes Verzeichnis an. */
+const iconCacheVerzeichnis = path.join(umgebung.hmgrHome, 'icon-cache');
+/** Intervall des selbsttätigen Aktualisierens (E44): fest, keine Einstellung. */
+const SECHS_STUNDEN_MS = 6 * 60 * 60 * 1000;
+/**
+ * Fake der claude-CLI für den Smoke-Test (E40 R4), nach dem Muster von `fakeClaude` in
+ * tests/helfer.ts: nie `code: 0`, also ohne Plugin-Fähigkeit, wie ohne installierte CLI. So fasst
+ * ein automatisierter Lauf formal nie die echte claude-CLI an, auch wenn sie auf dem PATH liegt.
+ */
+const smoketestClaudeAusfuehrer = async () => ({ stdout: '', code: 1 });
+let hauptfenster = null;
+/**
+ * Rückfrage-Port als Dialog im Renderer (E28, E34): der Main-Prozess schickt die Frage per
+ * `webContents.send`, der Renderer zeigt einen <dialog> im Stil des Entwurfs und schickt die
+ * Antwort über einen Kanal mit Korrelations-ID zurück. Ohne offenes Fenster kann niemand antworten,
+ * dort gilt wie am Terminal ohne TTY: Nein bzw. keine Antwort (E34).
+ */
+class GuiRueckfrage {
+    ausstehend = new Map();
+    constructor() {
+        ipcMain.on('hmgr:rueckfrage:antwort', (_event, nachricht) => {
+            const aufloesen = this.ausstehend.get(nachricht.id);
+            if (aufloesen === undefined)
+                return;
+            this.ausstehend.delete(nachricht.id);
+            aufloesen(nachricht.antwort);
+        });
+    }
+    stellen(payload) {
+        if (hauptfenster === null)
+            return Promise.resolve(payload.art === 'bestaetigen' ? false : undefined);
+        const id = randomUUID();
+        return new Promise((aufloesen) => {
+            this.ausstehend.set(id, aufloesen);
+            hauptfenster?.webContents.send('hmgr:rueckfrage', { id, ...payload });
+        });
+    }
+    async bestaetigen(frage) {
+        const antwort = await this.stellen({ art: 'bestaetigen', frage });
+        return antwort === true;
+    }
+    async auswaehlen(frage, optionen) {
+        const antwort = await this.stellen({ art: 'auswaehlen', frage, optionen });
+        return typeof antwort === 'number' ? antwort : undefined;
+    }
+}
+const rueckfrage = new GuiRueckfrage();
+const { anwendungsfaelle } = bauen(umgebung, {
+    rueckfrage,
+    ...(smoketest ? { claudeAusfuehrer: smoketestClaudeAusfuehrer } : {}),
+});
+async function auffangen(fn) {
+    try {
+        return { ok: true, daten: await fn() };
+    }
+    catch (fehler) {
+        return { ok: false, fehler: fehler instanceof Error ? fehler.message : String(fehler) };
+    }
+}
+/** ZielZustand über IPC: Maps werden zu einfachen Objekten, der Rest ist schon JSON-tauglich. */
+function zielZustandSerialisieren(z) {
+    return {
+        ziel: z.ziel,
+        verzeichnis: z.verzeichnis,
+        eintraege: z.eintraege,
+        einschraenkungen: Object.fromEntries(z.einschraenkungen),
+        gruende: Object.fromEntries(z.gruende),
+        ignoriert: z.ignoriert,
+        uebernahme: Object.fromEntries(z.uebernahme),
+        istRegistriert: z.istRegistriert,
+        kannSkillOrdner: z.kannSkillOrdner,
+        ...(z.plugins === undefined ? {} : { plugins: z.plugins }),
+        ...(z.verwalteterSkillOrdner === undefined ? {} : { verwalteterSkillOrdner: z.verwalteterSkillOrdner }),
+    };
+}
+function zielAusIpc(harness, ort) {
+    return { harness, ort };
+}
+function registriereIpc() {
+    ipcMain.handle('hmgr:version', async () => auffangen(async () => app.getVersion()));
+    // Für pfadKurz im Renderer (Anzeige-Kürzung auf ~): nur lesend, nie in einen anderen Aufruf zurückgespeist.
+    ipcMain.handle('hmgr:home', async () => auffangen(async () => os.homedir()));
+    ipcMain.handle('hmgr:istZustand', async () => auffangen(async () => (await anwendungsfaelle.istZustand()).map(zielZustandSerialisieren)));
+    ipcMain.handle('hmgr:marketplaces', async () => auffangen(async () => (await anwendungsfaelle.marketplaces()).map((m) => ({
+        quelleText: quelleAlsText(m.quelle),
+        name: m.name,
+        plugins: m.plugins,
+    }))));
+    // Skill-Katalog über alle bekannten Quellen (E40 R3): über den Anwendungsfall `katalog`, nicht
+    // mehr direkt über die Ports. Eine nicht erreichbare Quelle trägt einen Fehlervermerk (E12-Muster
+    // wie istZustand/marketplaces), ihre Skills fehlen einfach in der flachen Liste.
+    ipcMain.handle('hmgr:skills', async () => auffangen(async () => {
+        const ergebnis = [];
+        for (const eintrag of await anwendungsfaelle.katalog()) {
+            if (eintrag.ref === undefined)
+                continue; // nicht erreichbar, keine Skills
+            for (const skill of eintrag.skills)
+                ergebnis.push({
+                    name: skill.name,
+                    pfad: skill.pfad,
+                    ...(skill.beschreibung === undefined ? {} : { beschreibung: skill.beschreibung }),
+                    ...(skill.nurPerBefehl === undefined ? {} : { nurPerBefehl: skill.nurPerBefehl }),
+                    ...(skill.nichtPerBefehl === undefined ? {} : { nichtPerBefehl: skill.nichtPerBefehl }),
+                    ...(skill.registriertHooks === undefined ? {} : { registriertHooks: skill.registriertHooks }),
+                    ...(skill.werkzeugeErlaubt === undefined ? {} : { werkzeugeErlaubt: skill.werkzeugeErlaubt }),
+                    ...(skill.kompatibilitaet === undefined ? {} : { kompatibilitaet: skill.kompatibilitaet }),
+                    ...(skill.modell === undefined ? {} : { modell: skill.modell }),
+                    ...(skill.eigenerKontext === undefined ? {} : { eigenerKontext: skill.eigenerKontext }),
+                    ...(skill.argumentHinweis === undefined ? {} : { argumentHinweis: skill.argumentHinweis }),
+                    quelleText: quelleAlsText(eintrag.quelle),
+                    quelleName: quelleName(eintrag.quelle),
+                    quelleSchluessel: quelleSchluessel(eintrag.quelle),
+                    ref: eintrag.ref,
+                });
+        }
+        return ergebnis;
+    }));
+    // Nur die Herkunft, ohne die Quellen zu lesen: der Katalog daneben tut das schon.
+    ipcMain.handle('hmgr:quellen', async () => auffangen(async () => (await anwendungsfaelle.quellen()).map((quelle) => ({
+        art: quelle.art,
+        text: quelleAlsText(quelle),
+        name: quelleName(quelle),
+    }))));
+    // Quelle-Verwaltung in den Einstellungen (E54, E59): Text-zu-Quelle passiert im Main-Prozess, der
+    // Renderer kennt nur Zeichenketten. Der Anzeigename kommt serverseitig mit, damit dem Renderer nie
+    // ein weggefiltertes Feld fehlt (E59: „name" ist reine Anzeige, geht nicht in quelleAusText ein).
+    ipcMain.handle('hmgr:quelleHinzufuegen', async (_event, text, name) => auffangen(async () => {
+        const ergebnis = await anwendungsfaelle.quelleHinzufuegen(quelleAusText(text), name);
+        return {
+            quelle: {
+                art: ergebnis.quelle.art,
+                text: quelleAlsText(ergebnis.quelle),
+                name: quelleName(ergebnis.quelle),
+            },
+            skills: ergebnis.skills,
+            marketplace: ergebnis.marketplace,
+            bekannt: ergebnis.bekannt,
+        };
+    }));
+    ipcMain.handle('hmgr:quelleEntfernen', async (_event, text) => auffangen(async () => anwendungsfaelle.quelleEntfernen(quelleAusText(text))));
+    ipcMain.handle('hmgr:quelleUmbenennen', async (_event, text, name) => auffangen(async () => {
+        const umbenannt = await anwendungsfaelle.quelleUmbenennen(quelleAusText(text), name);
+        return { art: umbenannt.art, text: quelleAlsText(umbenannt), name: quelleName(umbenannt) };
+    }));
+    // Aufräum-Angebot nach dem Entfernen einer Quelle (E58): Inventar vor dem eigentlichen Entfernen
+    // erheben (der Renderer ruft das, bevor er quelleEntfernen aufruft), dann bei Zustimmung abräumen.
+    // Beide Ergebnisse reichen unverändert durch: schon reine Daten, keine Maps oder Funktionen darin.
+    ipcMain.handle('hmgr:quelleAufraeumInventar', async (_event, text) => auffangen(async () => anwendungsfaelle.quelleAufraeumInventar(quelleAusText(text))));
+    ipcMain.handle('hmgr:quelleAufraeumen', async (_event, inventar) => auffangen(async () => anwendungsfaelle.quelleAufraeumen(inventar)));
+    // Die GUI arbeitet an einem Arbeitsverzeichnis wie die CLI mit --local (E57, F32): Links werden
+    // lokal gelegt und entfernt, der Zeiger bleibt unangetastet, der Kern hängt bei einer bestehenden
+    // Bindung von sich aus einen Hinweis an. Für Home und Profil ist `lokal` folgenlos (E26).
+    ipcMain.handle('hmgr:linkLegen', async (_event, args) => auffangen(async () => anwendungsfaelle.linkLegen({
+        skill: args.skill,
+        ziel: zielAusIpc(args.harness, args.ort),
+        ...(args.quelle === undefined ? {} : { quelle: args.quelle }),
+        lokal: args.ort.art === 'arbeitsverzeichnis',
+    })));
+    ipcMain.handle('hmgr:linkEntfernen', async (_event, args) => auffangen(async () => anwendungsfaelle.linkEntfernen({
+        skill: args.skill,
+        ziel: zielAusIpc(args.harness, args.ort),
+        lokal: args.ort.art === 'arbeitsverzeichnis',
+    })));
+    ipcMain.handle('hmgr:eintragIgnorieren', async (_event, args) => auffangen(async () => anwendungsfaelle.eintragIgnorieren({ ziel: zielAusIpc(args.harness, args.ort), name: args.name })));
+    ipcMain.handle('hmgr:eintragBeachten', async (_event, args) => auffangen(async () => anwendungsfaelle.eintragBeachten({ ziel: zielAusIpc(args.harness, args.ort), name: args.name })));
+    // Auch die Übernahme legt Links und schriebe ohne `lokal` den Zeiger (E31 über linkAusFund), sie
+    // trifft also dieselbe Sperre wie link (E57). In der GUI arbeitet sie darum wie die CLI mit
+    // --local (F32), sonst bräche der Knopf an jedem gebundenen Arbeitsverzeichnis ab.
+    ipcMain.handle('hmgr:uebernehmen', async (_event, args) => auffangen(async () => anwendungsfaelle.uebernehmen({
+        ziel: zielAusIpc(args.harness, args.ort),
+        ...(args.name === undefined ? {} : { name: args.name }),
+        probelauf: args.probelauf,
+        lokal: args.ort.art === 'arbeitsverzeichnis',
+    })));
+    ipcMain.handle('hmgr:eintragLoeschen', async (_event, args) => auffangen(async () => anwendungsfaelle.eintragLoeschen({ ziel: zielAusIpc(args.harness, args.ort), name: args.name })));
+    ipcMain.handle('hmgr:aktualisieren', async (_event, args) => auffangen(async () => anwendungsfaelle.aktualisieren(args)));
+    ipcMain.handle('hmgr:arbeitsverzeichnisHinzufuegen', async (_event, pfad) => auffangen(async () => anwendungsfaelle.arbeitsverzeichnisHinzufuegen(pfad)));
+    ipcMain.handle('hmgr:arbeitsverzeichnisVergessen', async (_event, pfad) => auffangen(async () => anwendungsfaelle.arbeitsverzeichnisVergessen(pfad)));
+    // Nativer Verzeichnis-Dialog fürs Pfadfeld in „Verzeichnis hinzufügen" (A1). Im Smoke-Test darf
+    // nie ein echter Systemdialog aufgehen: sofort null, wie bei Abbruch.
+    ipcMain.handle('hmgr:verzeichnisWaehlen', async () => auffangen(async () => {
+        if (smoketest || hauptfenster === null)
+            return null;
+        const ergebnis = await dialog.showOpenDialog(hauptfenster, {
+            properties: ['openDirectory', 'createDirectory'],
+        });
+        if (ergebnis.canceled || ergebnis.filePaths.length === 0)
+            return null;
+        return ergebnis.filePaths[0] ?? null;
+    }));
+    // Harness-Schalter im Einstellungen-Modal (E38, GRILL.md Entwurfskritik 4).
+    ipcMain.handle('hmgr:harnessTypen', async () => auffangen(async () => anwendungsfaelle.harnessTypen()));
+    ipcMain.handle('hmgr:aktiveHarnesses', async () => auffangen(async () => anwendungsfaelle.aktiveHarnesses()));
+    // Für den Vermerk „nicht installiert" an den Schaltern (E42).
+    ipcMain.handle('hmgr:nichtVorhandeneHarnesses', async () => auffangen(async () => anwendungsfaelle.nichtVorhandeneHarnesses()));
+    ipcMain.handle('hmgr:harnessAktivieren', async (_event, name) => auffangen(async () => anwendungsfaelle.harnessAktivieren(name)));
+    ipcMain.handle('hmgr:harnessDeaktivieren', async (_event, name) => auffangen(async () => anwendungsfaelle.harnessDeaktivieren(name)));
+    ipcMain.handle('hmgr:saeubern', async (_event, name) => auffangen(async () => anwendungsfaelle.saeubern(name)));
+    // Verwalteter Hermes-Skill-Ordner (E56): Zeigen kommt schon über hmgr:istZustand, hier nur Ändern.
+    ipcMain.handle('hmgr:skillOrdnerFestlegen', async (_event, args) => auffangen(async () => anwendungsfaelle.skillOrdnerFestlegen(zielAusIpc(args.harness, args.ort), args.pfad)));
+    ipcMain.handle('hmgr:skillOrdnerEntfernen', async (_event, args) => auffangen(async () => anwendungsfaelle.skillOrdnerEntfernen(zielAusIpc(args.harness, args.ort))));
+    ipcMain.handle('hmgr:skillOrdnerLoeschen', async (_event, args) => auffangen(async () => anwendungsfaelle.skillOrdnerLoeschen(zielAusIpc(args.harness, args.ort), args.pfad)));
+    // Quellen-Icon (E60): nur im Main-Prozess geladen, als data-URL geliefert (CSP erlaubt img-src
+    // data:). Im Smoke-Test nie ein Netzzugriff: sofort null, der Renderer zeigt dann das generische
+    // Symbol. Ein Fehlschlag wirft nie (auffangen fängt ihn, iconFuerQuelle selbst wirft ohnehin nicht).
+    ipcMain.handle('hmgr:icon', async (_event, quelleText) => auffangen(async () => {
+        if (smoketest)
+            return null;
+        return iconFuerQuelle(quelleAusText(quelleText), { cacheVerzeichnis: iconCacheVerzeichnis });
+    }));
+    // Quelle öffnen (E60): die Protokoll-Weiche steht in oeffnen.ts (rein, testbar), hier nur die
+    // Wirkung. `shell.openExternal` bekommt ausschließlich http(s)-URLs, `shell.openPath` nur einen
+    // Ordner, den es wirklich gibt — nichts anderes wird zugelassen. Alles, was es gibt, aber kein
+    // Ordner ist, wird im Finder nur gezeigt, nicht geöffnet: `openPath` startet sonst eine Datei
+    // mit ihrem Standardprogramm, und ein Pfad aus dem Renderer soll nichts starten können.
+    ipcMain.handle('hmgr:quelleOeffnen', async (_event, quelleText) => auffangen(async () => {
+        const entscheidung = entscheideOeffnen(quelleAusText(quelleText));
+        if (entscheidung.art === 'browser')
+            await shell.openExternal(entscheidung.url);
+        else if (entscheidung.art === 'ordner') {
+            const info = await stat(entscheidung.pfad).catch(() => undefined);
+            if (info === undefined)
+                throw new Error(`Es gibt „${entscheidung.pfad}" nicht (mehr).`);
+            if (info.isDirectory())
+                await shell.openPath(entscheidung.pfad);
+            else
+                shell.showItemInFolder(entscheidung.pfad);
+        }
+        return entscheidung;
+    }));
+}
+function fensterOeffnen() {
+    hauptfenster = new BrowserWindow({
+        width: 1280,
+        height: 860,
+        minWidth: 860,
+        minHeight: 560,
+        backgroundColor: '#E3E7E0', // --platte, verhindert einen weißen Blitz beim Start
+        // Im Smoke-Test bleibt das Fenster unsichtbar: der Renderer lädt trotzdem vollständig, der
+        // DOM-Auszug kommt per executeJavaScript. So klaut ein automatisierter Lauf niemandem den
+        // Eingabefokus und öffnet kein sichtbares Fenster.
+        show: !smoketest,
+        webPreferences: {
+            preload: path.join(hierVerzeichnis, 'preload.cjs'),
+            contextIsolation: true,
+            nodeIntegration: false,
+            sandbox: true,
+        },
+    });
+    hauptfenster.on('closed', () => {
+        hauptfenster = null;
+    });
+    // Renderer-Konsole im Main-Log, für Fehlersuche und den Smoke-Test.
+    hauptfenster.webContents.on('console-message', (event) => {
+        console.log(`[renderer] ${event.message}`);
+    });
+    // Nur für den Smoke-Test (scripts/gui-smoke-test.ts): ein DOM-Auszug im Log, danach Ende.
+    if (smoketest) {
+        const fenster = hauptfenster;
+        fenster.webContents.once('did-finish-load', () => {
+            setTimeout(() => {
+                void fenster.webContents
+                    .executeJavaScript(`(async () => {
+              // Einstellungen-Modal (E40 R2): öffnen, die Harness-Schalter ablesen, wieder schließen.
+              document.getElementById('einstellungen')?.click();
+              var einstellungenOffen = document.getElementById('d-einstellungen')?.open === true;
+              var harnessSchalter = Array.from(document.querySelectorAll('#harnessliste input[type=checkbox]'))
+                .map((i) => i.dataset.harness + ':' + i.checked)
+                .join(',');
+              // Quellen-Abschnitt der Einstellungen (E54): Knopf und Dialoge vorhanden, der
+              // Hinzufügen-Dialog lässt sich öffnen und per Abbrechen ohne Fehler wieder schließen.
+              // Kein echter Quellen-Lauf: der Abbrechen-Knopf löst keinen IPC-Aufruf aus.
+              var quelleneuVorhanden = document.getElementById('quelleneu') !== null;
+              var dialogeQuelleVorhanden =
+                document.getElementById('d-quelle') !== null && document.getElementById('d-quelle-vergessen') !== null;
+              var quelleFehler = null;
+              var dQuelleOffenNachOeffnen = false;
+              var dQuelleOffenNachAbbrechen = true;
+              try {
+                document.getElementById('quelleneu')?.click();
+                dQuelleOffenNachOeffnen = document.getElementById('d-quelle')?.open === true;
+                document.querySelector('#d-quelle button[value="abbruch"]')?.click();
+                dQuelleOffenNachAbbrechen = document.getElementById('d-quelle')?.open === true;
+              } catch (fehler) {
+                quelleFehler = String(fehler);
+              }
+              // Aufräum-Angebot nach Quelle entfernen (E58): kein echter Lauf (der würde Checkouts
+              // und Links wirklich löschen), nur ob der Dialog existiert und sich öffnen und über
+              // Behalten schließen lässt, ohne Fehler.
+              var dialogQuelleAufraeumenVorhanden = document.getElementById('d-quelle-aufraeumen') !== null;
+              var quelleAufraeumenFehler = null;
+              var dQuelleAufraeumenOffenNachOeffnen = false;
+              var dQuelleAufraeumenOffenNachBehalten = true;
+              try {
+                var dQuelleAufraeumen = document.getElementById('d-quelle-aufraeumen');
+                dQuelleAufraeumen?.showModal();
+                dQuelleAufraeumenOffenNachOeffnen = dQuelleAufraeumen?.open === true;
+                document.querySelector('#d-quelle-aufraeumen button[value="behalten"]')?.click();
+                dQuelleAufraeumenOffenNachBehalten = dQuelleAufraeumen?.open === true;
+              } catch (fehler) {
+                quelleAufraeumenFehler = String(fehler);
+              }
+              // Anzeigename der Quelle (E59): die Einstellungen-Liste zeigt den abgeleiteten Namen
+              // „skills-repo" statt der vollen Fixture-URL, das Namensfeld im Hinzufügen-Dialog gibt
+              // es zusätzlich zum URL/Pfad-Feld.
+              var quellenlisteNamen = Array.from(document.querySelectorAll('#quellenliste b'))
+                .map((b) => b.textContent)
+                .join(',');
+              var dqNameVorhanden = document.getElementById('dq-name') !== null;
+              // Umbenennen (E59): der Knopf je Quelle öffnet den Dialog mit dem aktuellen Namen im
+              // Feld, Abbrechen schließt ihn wieder. Beide Knöpfe der Zeile liegen zusammen in
+              // einem Kasten, sonst lägen sie im Grid übereinander.
+              var quellenknoepfeZahl = document.querySelectorAll('#quellenliste .quellenknoepfe').length;
+              var quelleUmbenennenFehler = null;
+              var dQuUOffenNachOeffnen = false;
+              var dQuUName = null;
+              var dQuUOffenNachAbbrechen = true;
+              try {
+                var dQuU = document.getElementById('d-quelle-umbenennen');
+                // E60: der Umbenennen-Knopf ist jetzt ein Stift-Icon-Knopf ohne Text (Klasse
+                // „umbenennen", aria-label statt Beschriftung).
+                document.querySelector('#quellenliste .umbenennen')?.click();
+                dQuUOffenNachOeffnen = dQuU?.open === true;
+                dQuUName = document.getElementById('dqu-name')?.value ?? null;
+                document.querySelector('#d-quelle-umbenennen button[value="abbruch"]')?.click();
+                dQuUOffenNachAbbrechen = dQuU?.open === true;
+              } catch (fehler) {
+                quelleUmbenennenFehler = String(fehler);
+              }
+              document.getElementById('d-einstellungen')?.close();
+              // Konfigzeile am Hermes-Ziel (E56): der verwaltete Pfad steht in der Karte, auch
+              // ungeklappt (hidden ändert textContent nicht). Dazu der Festlegen-Weg am unmanaged
+              // Profil, Öffnen und Abbrechen ohne Fehler, nach dem Muster der d-quelle-Prüfungen.
+              var konfigzeileEl = document.querySelector('.konfigzeile');
+              var konfigzeileText = konfigzeileEl ? konfigzeileEl.textContent.replace(/\\s+/g, ' ').trim() : null;
+              var skillOrdnerFehler = null;
+              var dSkillordnerOffenNachOeffnen = false;
+              var dSkillordnerOffenNachAbbrechen = true;
+              try {
+                var festlegenKnopf = Array.from(document.querySelectorAll('button'))
+                  .find((b) => b.textContent === 'Skill-Ordner festlegen …');
+                festlegenKnopf?.click();
+                dSkillordnerOffenNachOeffnen = document.getElementById('d-skillordner')?.open === true;
+                document.querySelector('#d-skillordner button[value="abbruch"]')?.click();
+                dSkillordnerOffenNachAbbrechen = document.getElementById('d-skillordner')?.open === true;
+              } catch (fehler) {
+                skillOrdnerFehler = String(fehler);
+              }
+              // E60: Beschreibung in der Ziel-Tabelle (nicht nur im Katalog), „manuell" entfällt,
+              // Zahnrad statt Sonne am Einstellungen-Knopf.
+              var zielBeschreibung = document.querySelector('#zielliste .linkliste .was')?.textContent ?? null;
+              var zielManuellVorhanden = (document.getElementById('zielliste')?.textContent ?? '').includes('manuell');
+              var zahnradVorhanden = (document.querySelector('#einstellungen svg')?.innerHTML ?? '').includes('6.47 3.56');
+              // Katalog (E40 R3, R5): Beschreibung aus dem Fixture muss in der Skill-Zeile stehen.
+              document.querySelector('[data-ansicht="katalog"]')?.click();
+              var katalogBeschreibung = document.querySelector('#katalog .zeile .beschreibung')?.textContent ?? null;
+              // Besonderheiten aus dem Frontmatter (E55): Marken an der Zeile, Details erst nach
+              // einem Klick auf den Aufklapp-Knopf.
+              var katalogMarken = document.querySelector('#katalog .zeile .marken')?.textContent
+                ?.replace(/\\s+/g, ' ').trim() ?? null;
+              var aufklapp = document.querySelector('#katalog .zeile .aufklappknopf');
+              var katalogDetailsZu = document.querySelector('#katalog .zeile .skillkoerper')?.hidden ?? null;
+              aufklapp?.click();
+              var katalogAufgeklappt = aufklapp?.getAttribute('aria-expanded') ?? null;
+              var katalogDetails = document.querySelector('#katalog .zeile .skillkoerper:not([hidden])')?.textContent
+                ?.replace(/\\s+/g, ' ').trim() ?? null;
+              // Sicherheitsrelevante Marken (F11): Hooks und Werkzeuge tragen die warnende Klasse.
+              var katalogMarkenWarnend = Array.from(document.querySelectorAll('#katalog .zeile .merker.warnend'))
+                .map((m) => m.textContent).join(',');
+              // Skills-hinzufügen-Dialog (F13): dieselben Marken an der Wahlzeile.
+              var dskKnopf = Array.from(document.querySelectorAll('button'))
+                .find((b) => b.textContent === 'Skills hinzufügen');
+              var dskMarken = null;
+              if (dskKnopf) {
+                dskKnopf.click();
+                dskMarken = document.querySelector('#dsk-liste .wahlzeile .marken')?.textContent
+                  ?.replace(/\\s+/g, ' ').trim() ?? null;
+                document.getElementById('d-skills')?.close();
+              }
+              // Schriften aus fonts/ (Zusatzpunkt 6): erzwingt das Laden und belegt es danach.
+              await Promise.all([
+                document.fonts.load('400 16px Inter'),
+                document.fonts.load('500 16px "JetBrains Mono"'),
+              ]);
+              return JSON.stringify({
+                titel: document.title,
+                kopfzahlen: document.getElementById('kopfzahlen')?.textContent,
+                zielliste: document.getElementById('zielliste')?.textContent?.replace(/\\s+/g, ' ').trim().slice(0, 600),
+                meldung: document.getElementById('meldungtext')?.textContent,
+                einstellungenOffen,
+                harnessSchalter,
+                zielBeschreibung,
+                zielManuellVorhanden,
+                zahnradVorhanden,
+                katalogBeschreibung,
+                katalogMarken,
+                katalogDetailsZu,
+                katalogAufgeklappt,
+                katalogDetails,
+                katalogMarkenWarnend,
+                dskMarken,
+                interGeladen: document.fonts.check('400 16px Inter'),
+                monoGeladen: document.fonts.check('500 16px "JetBrains Mono"'),
+                quelleneuVorhanden,
+                dialogeQuelleVorhanden,
+                quellenlisteNamen,
+                dqNameVorhanden,
+                quellenknoepfeZahl,
+                dQuUOffenNachOeffnen,
+                dQuUName,
+                dQuUOffenNachAbbrechen,
+                quelleUmbenennenFehler,
+                dQuelleOffenNachOeffnen,
+                dQuelleOffenNachAbbrechen,
+                quelleFehler,
+                dialogQuelleAufraeumenVorhanden,
+                dQuelleAufraeumenOffenNachOeffnen,
+                dQuelleAufraeumenOffenNachBehalten,
+                quelleAufraeumenFehler,
+                // Hinweiszeile im Erfolgsdialog (E26, F32): vorhanden und im Ruhezustand leer.
+                deHinweisVorhanden: document.getElementById('de-hinweis') !== null,
+                deHinweisVerborgen: document.getElementById('de-hinweis')?.hidden === true,
+                konfigzeileText,
+                dSkillordnerOffenNachOeffnen,
+                dSkillordnerOffenNachAbbrechen,
+                skillOrdnerFehler,
+              });
+            })()`)
+                    .then((auszug) => console.log(`[smoke] DOM-Auszug: ${auszug}`))
+                    .finally(() => app.quit());
+            }, 3000);
+        });
+    }
+    // Selbsttätiges Aktualisieren (E44): einmal, sobald der Renderer bereit ist, danach alle sechs
+    // Stunden, solange das Fenster offen bleibt. Im Smoke-Test nie, sonst würde ein automatisierter
+    // Lauf einen echten Git-Fetch anstoßen.
+    if (!smoketest) {
+        const fenster = hauptfenster;
+        fenster.webContents.once('did-finish-load', () => {
+            fenster.webContents.send('hmgr:aktualisierenAnstossen');
+        });
+        const intervall = setInterval(() => fenster.webContents.send('hmgr:aktualisierenAnstossen'), SECHS_STUNDEN_MS);
+        fenster.on('closed', () => clearInterval(intervall));
+    }
+    void hauptfenster.loadFile(path.join(hierVerzeichnis, 'renderer', 'index.html'));
+}
+registriereIpc();
+app.whenReady().then(() => {
+    // Im Smoke-Test kein Dock-Icon und kein Fokuswechsel: das Fenster bleibt unsichtbar (show:false
+    // oben), macOS würde aber ohne diese Zeile trotzdem ein Dock-Icon zeigen und aktivieren.
+    if (smoketest && process.platform === 'darwin')
+        app.dock?.hide();
+    fensterOeffnen();
+    app.on('activate', () => {
+        if (BrowserWindow.getAllWindows().length === 0)
+            fensterOeffnen();
+    });
+});
+app.on('window-all-closed', () => {
+    if (process.platform !== 'darwin')
+        app.quit();
+});

package/dist/gui/oeffnen.js

@@ -0,0 +1,33 @@
+// Entscheidung, wie ein Klick auf eine Quelle sie öffnet (E60). Reine Funktion, ohne Electron:
+// der IPC-Handler in main.ts ruft sie und reicht das Ergebnis an `shell.openExternal` (nur für
+// http/https) oder `shell.openPath` (lokaler Ordner) weiter — nichts anderes wird zugelassen,
+// kein beliebiges Protokoll geht an eine der beiden Electron-Funktionen.
+import { fileURLToPath } from 'node:url';
+import { urlOrt } from "../kern/quelle-ort.js";
+/**
+ * http(s)-Quellen öffnen ihre Adresse direkt im Browser. Eine SSH- oder scp-Adresse
+ * (`git@host:besitzer/repo.git`) hat keine Webseite als Adresse, aber Host, Besitzer und Repo sind
+ * bekannt (E36), also wird daraus die https-Repo-Seite gebaut — `shell.openExternal` bekommt so nie
+ * die ssh-Adresse selbst zu sehen. Lokale Quellen und `file://`-Quellen öffnen ihren Pfad im
+ * Finder. Alles, woraus sich weder eine http(s)-Adresse noch ein Pfad gewinnen lässt, wird
+ * abgelehnt: kein anderes Protokoll geht an eine Electron-Shell-Funktion.
+ */
+export function entscheideOeffnen(quelle) {
+    if (quelle.art === 'lokal')
+        return { art: 'ordner', pfad: quelle.pfad };
+    const text = quelle.url.trim();
+    if (/^https?:\/\//i.test(text))
+        return { art: 'browser', url: text };
+    if (/^file:\/\//i.test(text)) {
+        try {
+            return { art: 'ordner', pfad: fileURLToPath(text) };
+        }
+        catch {
+            return { art: 'abgelehnt' };
+        }
+    }
+    const ort = urlOrt(text);
+    if (ort && ort.host !== 'local')
+        return { art: 'browser', url: `https://${ort.host}/${ort.besitzer}/${ort.repo}` };
+    return { art: 'abgelehnt' };
+}