hmgr 0.0.20 → 0.0.22

package/dist/gui/main.js

@@ -13,6 +13,7 @@ import { fileURLToPath } from 'node:url';
 import { bauen, umgebungLesen } from "../cli/main.js";
 import { quelleAlsText, quelleAusText } from "../adapter/quelle-text.js";
 import { paketVersion } from "../adapter/paket-version.js";
+import { infoPlistPfad, MeldungsPuffer, neuereVersionAufPlatte } from "./selbst-update.js";
 import { quelleName, quelleSchluessel } from "../kern/modell.js";
 import { kannProfile } from "../ports/harness.js";
 import { iconFuerQuelle } from "./icons.js";
@@ -27,6 +28,8 @@ const smoketest = process.env.HMGR_GUI_SMOKETEST === '1';
 // E84 Teil 1: Pfad eines im Fixture noch unbekannten Verzeichnisses, das der Smoke-Lauf per Dialog
 // hinzufügt, um den Sprung zur neuen Karte zu belegen. Nur zur Konstruktionszeit des DOM-Auszug-
 // Skripts gelesen (Node-Seite), nicht zur Laufzeit im Renderer.
+/** E90-Nachtrag: Smoke-Lauf, in dem die Platten-Erkennung schon vor dem Laden der Seite feuert. */
+const smoketestFrueh = process.env.HMGR_GUI_SMOKE_FRUEH === '1';
 const smoketestNeuesVerzeichnis = process.env.HMGR_SMOKETEST_NEUES_VERZEICHNIS ?? '';
 /**
  * Nur eine hmgr-Instanz je Nutzer (E67). Grund: zwei laufende Fenster schrieben nacheinander auf
@@ -331,10 +334,18 @@ function registriereIpc() {
     // Neustart-Knopf an der GUI-Update-Zeile (E80): installiert das geladene Paket sofort, statt auf
     // das nächste Beenden zu warten. Im Smoke-Test ein No-op — dort läuft `updatePruefen` ohnehin nie,
     // der Knopf bleibt verborgen, aber ein Absturz durch ein fehlendes Update darf trotzdem nie sein.
+    // E90: mit einem geladenen Windows-Paket `quitAndInstall`, sonst (macOS: das Bundle liegt schon
+    // ersetzt auf der Platte) ein Neustart des Prozesses. Entscheidend ist das Merker-Flag, nicht die
+    // Plattform allein.
     ipcMain.on('hmgr:neuStarten', () => {
         if (smoketest)
             return;
-        autoUpdater.quitAndInstall();
+        if (geladenesPaketVorhanden) {
+            autoUpdater.quitAndInstall();
+            return;
+        }
+        app.relaunch();
+        app.exit(0);
     });
     ipcMain.handle('hmgr:arbeitsverzeichnisHinzufuegen', async (_event, pfad) => auffangen(async () => anwendungsfaelle.arbeitsverzeichnisHinzufuegen(pfad)));
     ipcMain.handle('hmgr:arbeitsverzeichnisVergessen', async (_event, pfad) => auffangen(async () => anwendungsfaelle.arbeitsverzeichnisVergessen(pfad)));
@@ -498,8 +509,12 @@ function fensterOeffnen() {
             sandbox: true,
         },
     });
+    meldungsPuffer.bereitAbmelden();
+    hauptfenster.webContents.on('did-start-loading', () => meldungsPuffer.bereitAbmelden());
+    hauptfenster.webContents.on('did-finish-load', () => meldungsPuffer.bereitSetzen());
     hauptfenster.on('closed', () => {
         hauptfenster = null;
+        zuletztGemeldeteGuiVersion = null;
     });
     // Der <title> der index.html setzt den Fenstertitel beim Laden sonst zurück und überschriebe die
     // Option oben (E72). Der DOM-Titel bleibt dabei, wie er ist, nur das Fenster folgt ihm nicht mehr.
@@ -509,7 +524,21 @@ function fensterOeffnen() {
         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) {
+    if (smoketest && smoketestFrueh) {
+        // E90-Nachtrag: die Platten-Erkennung feuert schon vor dem Laden der Seite (direkt nach der
+        // Fenstererzeugung); die Meldung muss trotzdem ankommen. Kein großer DOM-Auszug, nur das Modal.
+        const fenster = hauptfenster;
+        plattenVersionPruefen(true);
+        fenster.webContents.once('did-finish-load', () => {
+            setTimeout(() => {
+                void fenster.webContents
+                    .executeJavaScript(NEUSTART_AUSZUG_SKRIPT)
+                    .then((auszug) => console.log(`[smoke] Neustart-Modal früh: ${String(auszug)}`))
+                    .finally(() => app.quit());
+            }, 1500);
+        });
+    }
+    if (smoketest && !smoketestFrueh) {
         const fenster = hauptfenster;
         fenster.webContents.once('did-finish-load', () => {
             setTimeout(() => {
@@ -1202,6 +1231,20 @@ function fensterOeffnen() {
                     // E72: der Fenstertitel steht nicht im DOM (dort steht weiter der <title> der
                     // index.html), er lässt sich nur hier im Main-Prozess ablesen.
                     .then(() => console.log(`[smoke] Fenster: ${JSON.stringify({ fenstertitel: fenster.getTitle() })}`))
+                    // E90: erst nach dem DOM-Auszug die Platten-Erkennung auslösen (Naht über
+                    // HMGR_GUI_SMOKE_PLATTENVERSION), damit die Leer-Prüfungen der Update-Zeile darin gelten.
+                    // Danach ein zweiter, kleiner Auszug nur zum Neustart-Modal.
+                    .then(async () => {
+                    if (process.env.HMGR_GUI_SMOKE_PLATTENVERSION === undefined)
+                        return;
+                    // Der Rest-Dialog (d-erfolg) öffnet über einen 90-ms-Timer nach der letzten Aktion des
+                    // Auszugs; ohne dieses Abwarten löste die Erkennung mal vor, mal nach ihm aus.
+                    await fenster.webContents.executeJavaScript(`new Promise(function (r) { var n = 0; (function w() { if (document.querySelector('dialog[open]') || ++n > 30) r(); else setTimeout(w, 50); })(); })`);
+                    plattenVersionPruefen(true);
+                    await new Promise((r) => setTimeout(r, 800));
+                    const auszug = await fenster.webContents.executeJavaScript(NEUSTART_AUSZUG_SKRIPT);
+                    console.log(`[smoke] Neustart-Modal: ${String(auszug)}`);
+                })
                     .finally(() => app.quit());
             }, 3000);
         });
@@ -1215,7 +1258,10 @@ function fensterOeffnen() {
         fenster.webContents.once('did-finish-load', () => {
             fenster.webContents.send('hmgr:aktualisierenAnstossen', 'start');
         });
-        const intervall = setInterval(() => fenster.webContents.send('hmgr:aktualisierenAnstossen', 'intervall'), SECHS_STUNDEN_MS);
+        const intervall = setInterval(() => {
+            fenster.webContents.send('hmgr:aktualisierenAnstossen', 'intervall');
+            plattenVersionPruefen();
+        }, SECHS_STUNDEN_MS);
         fenster.on('closed', () => clearInterval(intervall));
     }
     // Die GUI erfährt von Änderungen außerhalb ihrer selbst (E62): Fokus-Reload und Datei-Watcher.
@@ -1224,7 +1270,10 @@ function fensterOeffnen() {
     // Aktualisieren (E44): ein Event dürfte sonst in den DOM-Auszug pfuschen.
     if (!smoketest) {
         const fenster = hauptfenster;
-        fenster.on('focus', () => neuLadenAnstossen());
+        fenster.on('focus', () => {
+            neuLadenAnstossen();
+            plattenVersionPruefen();
+        });
         void beobachtetePfade().then((pfade) => {
             if (fenster.isDestroyed())
                 return; // Fenster schon zu, während die Pfade ermittelt wurden
@@ -1281,7 +1330,8 @@ function updatePruefen() {
                     .catch((fehler) => {
                     console.log(`[verlauf] ${fehler instanceof Error ? fehler.message : String(fehler)}`);
                 });
-                selbstUpdateMelden({ art: 'gui', version: guiVersion });
+                geladenesPaketVorhanden = true;
+                selbstUpdateMelden({ art: 'gui', version: guiVersion, neuStartNoetig: 'geladen' });
             });
         }
         void autoUpdater.checkForUpdatesAndNotify().catch((fehler) => {
@@ -1292,11 +1342,78 @@ function updatePruefen() {
         console.log(`[updater] ${fehler instanceof Error ? fehler.message : String(fehler)}`);
     }
 }
-/** Ein Hinweis für die Sidebar (E77). Ist das Fenster schon zu, verfällt er stillschweigend. */
-function selbstUpdateMelden(nachricht) {
+/** Das Skript für den Modal-Auszug im Smoke-Test (Neustart-Modal, Sidebar-Zeile, „Später"). */
+const NEUSTART_AUSZUG_SKRIPT = `(async () => {
+              var dlg = document.getElementById('d-neustart');
+              // Ein anderer Dialog steht noch offen (Rest des ersten Auszugs): das Modal wartet
+              // solange, und öffnet erst, wenn der andere zu ist.
+              var anderePlatzhalter = Array.from(document.querySelectorAll('dialog[open]')).filter(function (d) { return d !== dlg; });
+              var wartetSolangeAndererOffen = anderePlatzhalter.length > 0 && dlg?.open !== true;
+              anderePlatzhalter.forEach(function (d) { d.close(); });
+              await new Promise(function (r) { setTimeout(r, 300); });
+              var offen = dlg?.open === true;
+              var titel = document.getElementById('dn-titel')?.textContent ?? null;
+              var zeile = document.getElementById('selbstupdate-gui');
+              var zeileText = zeile && !zeile.hidden ? zeile.textContent : null;
+              var neustartKnopfSichtbar = document.getElementById('selbstupdate-neustart')?.hidden === false;
+              var knopfTexte = Array.from(dlg?.querySelectorAll('.dfuss button') ?? []).map(function (b) { return b.textContent; }).join('|');
+              dlg?.querySelector('button[value="spaeter"]')?.click();
+              var nachSpaeterOffen = dlg?.open === true;
+              return JSON.stringify({ wartetSolangeAndererOffen, offen, titel, zeileText, neustartKnopfSichtbar, knopfTexte, nachSpaeterOffen });
+            })()`;
+/**
+ * Ein Hinweis für die Sidebar (E77). Ist das Fenster schon zu, verfällt er stillschweigend. Solange
+ * die Seite nicht geladen ist, hat der Renderer seinen Listener noch nicht (E90-Nachtrag): der
+ * Puffer hält je Art die letzte Nachricht und sendet sie nach `did-finish-load` — das Skript am
+ * Ende des Bodys registriert `onSelbstUpdate` synchron, `did-finish-load` kommt erst danach.
+ */
+const meldungsPuffer = new MeldungsPuffer((nachricht) => {
     if (hauptfenster === null || hauptfenster.isDestroyed())
         return;
     hauptfenster.webContents.send('hmgr:selbstUpdate', nachricht);
+});
+function selbstUpdateMelden(nachricht) {
+    if (hauptfenster === null || hauptfenster.isDestroyed())
+        return;
+    meldungsPuffer.melden(nachricht);
+}
+/** Windows: ein Paket ist geladen und wartet auf `quitAndInstall` (E90, Merker für `hmgr:neuStarten`). */
+let geladenesPaketVorhanden = false;
+/** Die beim Start festgehaltene Version des laufenden Prozesses. */
+const laufendeVersion = paketVersion();
+const PLATTEN_PRUEFUNG_MIN_ABSTAND_MS = 30_000;
+let letztePlattenPruefung = 0;
+let zuletztGemeldeteGuiVersion = null;
+/**
+ * E90, macOS-Weg: das App-Bundle wird im Hintergrund vom Deploy-Skript (ditto/rsync) ersetzt, der
+ * laufende Prozess merkt das nicht. Verglichen wird die Version in `Contents/Info.plist` mit der
+ * beim Start festgehaltenen. Die Info.plist statt der package.json in `app.asar`, weil Electron den
+ * asar-Header je Pfad zwischenspeichert und ein ersetztes Archiv nicht neu liest. Nur gepackt und
+ * nur auf macOS (nur dort gibt es ein Bundle mit Info.plist); gedrosselt auf einen Lauf je 30 s.
+ * Im Smoke-Test liefert `HMGR_GUI_SMOKE_PLATTENVERSION` eine künstliche Platten-Version, sonst
+ * läuft dort nie eine echte Prüfung.
+ */
+function plattenVersionPruefen(erzwingen = false) {
+    let platte;
+    if (smoketest) {
+        if (!erzwingen)
+            return;
+        const kuenstlich = process.env.HMGR_GUI_SMOKE_PLATTENVERSION;
+        platte = kuenstlich !== undefined && kuenstlich !== '' ? kuenstlich : null;
+    }
+    else {
+        if (!app.isPackaged || process.platform !== 'darwin')
+            return;
+        const jetzt = Date.now();
+        if (jetzt - letztePlattenPruefung < PLATTEN_PRUEFUNG_MIN_ABSTAND_MS)
+            return;
+        letztePlattenPruefung = jetzt;
+        platte = neuereVersionAufPlatte(infoPlistPfad(process.execPath), laufendeVersion);
+    }
+    if (platte === null || platte === zuletztGemeldeteGuiVersion)
+        return;
+    zuletztGemeldeteGuiVersion = platte;
+    selbstUpdateMelden({ art: 'gui', version: platte, neuStartNoetig: 'installiert' });
 }
 /**
  * Die daneben installierte hmgr-CLI gegen npm (E77, F83=O1). Läuft auf allen Plattformen — anders

package/dist/gui/renderer/index.html

@@ -255,6 +255,21 @@
   </form>
 </dialog>
 
+<!-- Neustart-Angebot (E90): ein Update für hmgr selbst liegt bereit. -->
+<dialog id="d-neustart">
+  <form method="dialog">
+    <div class="dkopf">
+      <span class="etikett">Update</span>
+      <h3 id="dn-titel"></h3>
+      <p>hmgr startet dafür neu. Offene Dialoge gehen dabei verloren.</p>
+    </div>
+    <div class="dfuss">
+      <button class="knopf leise" value="spaeter">Später</button>
+      <button class="knopf signal" value="jetzt">Jetzt neu starten</button>
+    </div>
+  </form>
+</dialog>
+
 <dialog id="d-erfolg">
   <form method="dialog">
     <div class="dkopf">

package/dist/gui/renderer/renderer.js

@@ -2668,11 +2668,39 @@
      die CLI installiert die GUI nicht selbst (F82). Die CLI-Zeile ist seit E82 eine Warnung, keine
      bloße Ansage: eine alte CLI (vor 0.0.7, kennt --version nicht) schreibt dieselben Dateien
      (state.json, verlauf.json) wie die neue GUI und kennt Bundles, Verlauf und WSL-Heime nicht. */
+  /* Neustart-Modal (E90): je Version einmal. Nach „Später" kommt es für dieselbe Version nicht
+     wieder (nur im Speicher, ein App-Neustart setzt es zurück). Steht gerade ein anderer Dialog
+     offen, wartet es, bis der zu ist. */
+  var neustartAngebotVersion = null;
+  var neustartAbgelehnt = null;
+  function neustartAnbieten(version) {
+    if (version === neustartAbgelehnt) return;
+    neustartAngebotVersion = version;
+    neustartAngebotOeffnen();
+  }
+  function neustartAngebotOeffnen() {
+    if (neustartAngebotVersion === null || neustartAngebotVersion === neustartAbgelehnt) return;
+    if (document.querySelector('dialog[open]')) return;
+    $('dn-titel').textContent = 'hmgr ' + neustartAngebotVersion + ' ist bereit';
+    zeige($('d-neustart'));
+  }
+  $('d-neustart').addEventListener('close', function () {
+    if ($('d-neustart').returnValue === 'jetzt') window.hmgr.neuStarten();
+    else neustartAbgelehnt = neustartAngebotVersion;
+  });
+  // `close` bubbelt nicht, der Capture-Listener am Dokument sieht aber jeden geschlossenen Dialog.
+  document.addEventListener('close', function (ev) {
+    if (ev.target !== $('d-neustart')) setTimeout(neustartAngebotOeffnen, 0);
+  }, true);
+
   function selbstUpdateZeigen(nachricht) {
     if (nachricht.art === 'gui') {
-      $('selbstupdate-gui').textContent = 'hmgr ' + nachricht.version + ' bereit — wird beim Beenden installiert';
+      $('selbstupdate-gui').textContent = nachricht.neuStartNoetig === 'installiert'
+        ? 'hmgr ' + nachricht.version + ' ist installiert — Neustart lädt sie'
+        : 'hmgr ' + nachricht.version + ' bereit — wird beim Beenden installiert';
       $('selbstupdate-gui').hidden = false;
       $('selbstupdate-neustart').hidden = false;
+      neustartAnbieten(nachricht.version);
     } else if (nachricht.art === 'cli') {
       var p = $('selbstupdate-cli');
       p.textContent = '';

package/dist/gui/selbst-update.js

@@ -0,0 +1,105 @@
+// Erkennung „das App-Bundle auf der Platte ist neuer als der laufende Prozess" (E90). Reine
+// Funktionen ohne Electron-Import, damit sie ohne App testbar sind; das Verdrahten liegt in main.ts.
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+function zerlegen(version) {
+    const treffer = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(version.trim());
+    if (treffer === null)
+        return null;
+    return {
+        kern: [Number(treffer[1]), Number(treffer[2]), Number(treffer[3])],
+        vorab: treffer[4] === undefined ? [] : treffer[4].split('.'),
+    };
+}
+/** Semver-Rangfolge: negativ, 0 oder positiv; Vorabversion ist kleiner als ihre Release. */
+function vergleichen(a, b) {
+    for (let i = 0; i < 3; i++) {
+        const unterschied = a.kern[i] - b.kern[i];
+        if (unterschied !== 0)
+            return unterschied;
+    }
+    if (a.vorab.length === 0 && b.vorab.length === 0)
+        return 0;
+    if (a.vorab.length === 0)
+        return 1;
+    if (b.vorab.length === 0)
+        return -1;
+    for (let i = 0; i < Math.max(a.vorab.length, b.vorab.length); i++) {
+        const x = a.vorab[i];
+        const y = b.vorab[i];
+        if (x === undefined)
+            return -1;
+        if (y === undefined)
+            return 1;
+        const xZahl = /^\d+$/.test(x);
+        const yZahl = /^\d+$/.test(y);
+        if (xZahl && yZahl) {
+            if (Number(x) !== Number(y))
+                return Number(x) - Number(y);
+        }
+        else if (xZahl !== yZahl) {
+            return xZahl ? -1 : 1;
+        }
+        else if (x !== y) {
+            return x < y ? -1 : 1;
+        }
+    }
+    return 0;
+}
+/** `true`, wenn `platte` eine echt größere Version ist als `laufend`. Unlesbares gilt als „nein". */
+export function istNeuer(platte, laufend) {
+    const p = zerlegen(platte);
+    const l = zerlegen(laufend);
+    return p !== null && l !== null && vergleichen(p, l) > 0;
+}
+/** `…/hmgr.app/Contents/MacOS/hmgr` → `…/hmgr.app/Contents/Info.plist`. */
+export function infoPlistPfad(execPath) {
+    return path.join(path.dirname(execPath), '..', 'Info.plist');
+}
+/** Die CFBundleShortVersionString aus einer XML-Info.plist; `null` bei allem Unlesbaren. */
+export function plistVersion(plistPfad) {
+    try {
+        const text = readFileSync(plistPfad, 'utf8');
+        const treffer = /<key>CFBundleShortVersionString<\/key>\s*<string>([^<]*)<\/string>/.exec(text);
+        return treffer?.[1]?.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Die Platten-Version, wenn sie neuer ist als die laufende, sonst `null`. Wirft nie. */
+export function neuereVersionAufPlatte(plistPfad, laufend) {
+    const platte = plistVersion(plistPfad);
+    return platte !== null && istNeuer(platte, laufend) ? platte : null;
+}
+/**
+ * Puffer für Meldungen an den Renderer (E90-Nachtrag). Solange die Seite nicht geladen ist, hat der
+ * Renderer seinen Listener noch nicht registriert, ein `webContents.send` ginge ins Leere. Bis
+ * `bereitSetzen()` wird deshalb je `art` nur die letzte Nachricht behalten und dann einmal
+ * gesendet; danach geht alles sofort durch. `bereitAbmelden()` (neues Laden der Seite) schaltet
+ * wieder auf Puffern. Ohne Electron-Import, damit ohne App testbar.
+ */
+export class MeldungsPuffer {
+    bereit = false;
+    wartend = new Map();
+    senden;
+    constructor(senden) {
+        this.senden = senden;
+    }
+    melden(nachricht) {
+        if (this.bereit)
+            this.senden(nachricht);
+        else
+            this.wartend.set(nachricht.art, nachricht);
+    }
+    bereitSetzen() {
+        this.bereit = true;
+        const gepuffert = [...this.wartend.values()];
+        this.wartend.clear();
+        for (const nachricht of gepuffert)
+            this.senden(nachricht);
+    }
+    bereitAbmelden() {
+        this.bereit = false;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hmgr",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "description": "Harness Manager: Skills und Plugins für AI-Harnesses verwalten",
   "license": "MIT",
   "author": "Tim Kaufmann",