hmgr 0.0.20 → 0.0.21

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, neuereVersionAufPlatte } from "./selbst-update.js";
 import { quelleName, quelleSchluessel } from "../kern/modell.js";
 import { kannProfile } from "../ports/harness.js";
 import { iconFuerQuelle } from "./icons.js";
@@ -331,10 +332,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)));
@@ -500,6 +509,7 @@ function fensterOeffnen() {
     });
     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.
@@ -1202,6 +1212,34 @@ 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;
+                    plattenVersionPruefen(true);
+                    await new Promise((r) => setTimeout(r, 800));
+                    const auszug = await fenster.webContents.executeJavaScript(`(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 });
+            })()`);
+                    console.log(`[smoke] Neustart-Modal: ${String(auszug)}`);
+                })
                     .finally(() => app.quit());
             }, 3000);
         });
@@ -1215,7 +1253,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 +1265,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 +1325,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) => {
@@ -1298,6 +1343,44 @@ function selbstUpdateMelden(nachricht) {
         return;
     hauptfenster.webContents.send('hmgr:selbstUpdate', 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
  * als die GUI-Prüfung hängt sie an keinem Paket-Format und an keiner Signierung. Gemeldet wird nur,

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,74 @@
+// 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;
+}

package/package.json

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