hmgr 0.0.38 → 0.0.39

package/dist/gui/main.js

@@ -416,8 +416,11 @@ function registriereIpc() {
     }));
     // MCP-Ansicht (E61-Folgerunde): Whitelisting und der F39-Vermerk je Karte stehen in mcp-ansicht.ts
     // (rein, ohne Electron, wie oeffnen.ts und icons.ts), damit sie testbar sind. Der Main-Prozess
-    // ruft nur noch auf und liefert die eigene Prozess-Umgebung für die F39-Prüfung.
-    ipcMain.handle('hmgr:mcpUebersicht', async () => auffangen(async () => mcpUebersichtSerialisieren(await anwendungsfaelle.mcpUebersicht(), process.env)));
+    // ruft nur noch auf; die F39-Lage je Welt (lokal, WSL-Distro) kommt aus dem Kern (E107).
+    ipcMain.handle('hmgr:mcpUebersicht', async () => auffangen(async () => {
+        const uebersicht = await anwendungsfaelle.mcpUebersicht();
+        return mcpUebersichtSerialisieren(uebersicht, await anwendungsfaelle.mcpVariablenLage(uebersicht));
+    }));
     // Plätze für den Einhängen-Dialog (F42): die Fähigkeit hängt am Adapter, nicht am Namen (E16),
     // deshalb kommt die Liste unverändert aus dem Kern statt aus einer Harness-Fallunterscheidung hier.
     ipcMain.handle('hmgr:mcpPlaetze', async () => auffangen(async () => anwendungsfaelle.mcpPlaetze()));

package/dist/gui/mcp-ansicht.js

@@ -1,7 +1,7 @@
 // MCP-Ansicht der GUI (E61-Folgerunde): reine Umformung von Kern-Daten in IPC-taugliche, gewhiteliste
 // Objekte, ohne Electron — testbar wie oeffnen.ts und icons.ts. Der eigentliche IPC-Handler in
 // main.ts ruft diese Funktionen nur noch auf.
-import { variablenVerweise, } from "../kern/anwendungsfaelle.js";
+import {} from "../kern/anwendungsfaelle.js";
 /** Katalog-Eintrag über IPC: die bekannten Felder, nichts ungefiltert durchgereicht (E40 R3). */
 export function mcpEintragSerialisieren(eintrag) {
     return {
@@ -12,23 +12,14 @@ export function mcpEintragSerialisieren(eintrag) {
         konfig: eintrag.konfig,
     };
 }
-/**
- * F39 an der Katalog-Karte: dieselbe Prüf-Funktion wie beim tatsächlichen Einhängen
- * (`variablenVerweise`), hier aber nur gegen die übergebene Umgebung geprüft — ohne den
- * ortsbezogenen `.env`-Abgleich, der ist ortsspezifisch und bleibt dem eigentlichen Einhängen
- * vorbehalten (kommt von dort als `warnung` zurück).
- */
-export function mcpFehlendeVariablen(eintrag, umgebung) {
-    return variablenVerweise(eintrag.konfig).filter((name) => !(name in umgebung) || umgebung[name] === undefined);
-}
-/** Übersicht über IPC (E61-Folgerunde): Katalog-Einträge whitelisted, dazu der F39-Vermerk je Karte. */
-export function mcpUebersichtSerialisieren(uebersicht, umgebung) {
+/** Übersicht über IPC (E61-Folgerunde): Katalog-Einträge whitelisted, dazu je Karte die F39-Befunde je Welt (E107, `variablenWelten`). */
+export function mcpUebersichtSerialisieren(uebersicht, lage) {
     return {
         katalog: uebersicht.katalog.map((k) => ({
             eintrag: mcpEintragSerialisieren(k.eintrag),
             eingehaengt: k.eingehaengt,
             geteilteFundorte: k.geteilteFundorte,
-            fehlendeVariablen: mcpFehlendeVariablen(k.eintrag, umgebung),
+            variablenWelten: lage.get(k.eintrag.name) ?? [],
         })),
         unbekannt: uebersicht.unbekannt,
         unbekannteGeteilteFundorte: uebersicht.unbekannteGeteilteFundorte,

package/dist/gui/renderer/renderer.js

@@ -323,7 +323,7 @@
   // Homedirs je Harness (E78): je Eintrag { harness, heime: [{ adresse?, pfad, eingestellt }],
   // kannZusaetzliche }. Grundlage der Homedir-Zeilen in den Einstellungen.
   var HARNESS_HEIME = [];
-  // MCP-Katalog (E61-Folgerunde): je Eintrag { eintrag, eingehaengt, fehlendeVariablen }, dazu
+  // MCP-Katalog (E61-Folgerunde): je Eintrag { eintrag, eingehaengt, variablenWelten }, dazu
   // Einträge in Harness-Konfigurationen, die nicht im Katalog stehen (nur genannt). Seit F46 nur
   // noch Grundlage für den MCP-Abschnitt der Ziel-Karten (mcpZeilenFuerZiel), die MCP-Ansicht selbst
   // zeigt keine Fundorte mehr.
@@ -3071,13 +3071,11 @@
     return a;
   }
 
-  /** F39: die Prüf-Funktion ist dieselbe wie beim tatsächlichen Einhängen, hier aber nur gegen die
-      Prozess-Umgebung von hmgr (der Main-Prozess liefert `fehlendeVariablen` schon fertig mit der
-      Übersicht, ohne den ortsbezogenen .env-Abgleich, der bleibt dem Einhängen selbst vorbehalten
-      und kommt dann als `warnung` zurück). Wiederverwendet die bestehende .ruhezeile-Optik. */
-  function mcpWarnZeile(fehlend) {
-    var mehrzahl = fehlend.length > 1;
-    var namen = fehlend.map(function (v) { return '${' + v + '}'; }).join(', ');
+  /** F39 (E107): der Main-Prozess liefert je Karte `variablenWelten`, die Befunde je Welt (lokal oder
+      WSL-Distro), geprüft gegen dieselbe Umgebungsquelle wie das Einhängen — ohne den ortsbezogenen
+      .env-Abgleich, der bleibt dem Einhängen selbst vorbehalten und kommt dann als `warnung` zurück.
+      Je Welt mit Befund eine Zeile, Welten ohne Befund keine. Wiederverwendet die .ruhezeile-Optik. */
+  function mcpWarnZeile(text) {
     var rz = e('div', 'ruhezeile');
     var svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
     svg.setAttribute('viewBox', '0 0 16 16');
@@ -3085,12 +3083,35 @@
     svg.setAttribute('aria-hidden', 'true');
     svg.innerHTML = '<circle cx="8" cy="8" r="6.5"/><path d="M8 4.5v4M8 10.5v.5"/>';
     rz.appendChild(svg);
-    rz.appendChild(e('p', null, namen + (mehrzahl ? ' sind' : ' ist') + ' in der Umgebung von hmgr nicht gesetzt. Ob '
-      + (mehrzahl ? 'die Variablen' : 'die Variable') + ' beim Start des Harness gesetzt ' + (mehrzahl ? 'sind' : 'ist')
-      + ', kann hmgr nicht wissen.'));
+    rz.appendChild(e('p', null, text));
     return rz;
   }
 
+  function mcpWarnZeilen(welten) {
+    var mehrere = welten.some(function (w) { return w.distro !== undefined; });
+    var zeilen = [];
+    welten.forEach(function (w) {
+      if (w.ungeprueft) {
+        zeilen.push(mcpWarnZeile('hmgr konnte die Umgebung von WSL ' + w.distro + ' nicht lesen, die Verweise sind ungeprüft.'));
+        return;
+      }
+      if (w.fehlend.length === 0) return;
+      var mz = w.fehlend.length > 1;
+      var namen = w.fehlend.map(function (v) { return '${' + v + '}'; }).join(', ');
+      var verb = mz ? ' sind' : ' ist';
+      if (w.distro !== undefined) {
+        zeilen.push(mcpWarnZeile(namen + verb + ' in WSL ' + w.distro + ' nicht gesetzt (Login-Shell, interaktiv).'));
+      } else if (mehrere) {
+        zeilen.push(mcpWarnZeile(namen + verb + ' in Windows nicht gesetzt.'));
+      } else {
+        zeilen.push(mcpWarnZeile(namen + verb + ' in der Umgebung von hmgr nicht gesetzt. Ob '
+          + (mz ? 'die Variablen' : 'die Variable') + ' beim Start des Harness gesetzt ' + (mz ? 'sind' : 'ist')
+          + ', kann hmgr nicht wissen.'));
+      }
+    });
+    return zeilen;
+  }
+
   /** Notizen sind das Langsame am Eintrag (entwurf/gui.html): zugeklappt, öffnen sich nur, wenn
       jemand sie sucht. Der Wortlaut bleibt, wie er in der mcp.yaml steht, Zeilenumbrüche
       eingeschlossen (weiss-raum: pre-line in styles.css). */
@@ -3135,7 +3156,7 @@
     konf.appendChild(e('span', 'mono', mcpKonfigWortlaut(eintrag.konfig)));
     kEl.appendChild(konf);
 
-    if (k.fehlendeVariablen.length > 0) kEl.appendChild(mcpWarnZeile(k.fehlendeVariablen));
+    mcpWarnZeilen(k.variablenWelten).forEach(function (z) { kEl.appendChild(z); });
     if (eintrag.notizen) kEl.appendChild(mcpNotizenBlock(eintrag.notizen));
 
     return kEl;

package/dist/kern/anwendungsfaelle.js

@@ -394,6 +394,67 @@ export class Anwendungsfaelle {
             throw new McpUnbekannt(mcpName);
         return eintrag;
     }
+    /**
+     * Die Umgebung einer Welt (E107): ohne `distro` die Prozess-Umgebung, sonst die einer im Terminal
+     * der Distro gestarteten claude (E104). `undefined`, wenn die Distro-Umgebung nicht lesbar ist.
+     * Einzige Stelle dafür, geteilt von Einhängen-Warnung und Kartenhinweis.
+     */
+    async mcpUmgebungDerWelt(distro) {
+        if (distro === undefined)
+            return this.p.umgebung.variablen();
+        return await this.p.wsl.variablen(distro).catch(() => undefined);
+    }
+    /**
+     * F39 an der Katalog-Karte (E107): je Eintrag mit `${VAR}`-Verweisen die Welten, gegen die zu
+     * prüfen ist, jeweils mit Befund. Welten: die der Ziele, an denen der Eintrag eingehängt ist; sonst
+     * die der Ziele, an denen er einhängbar wäre (`ortBedienbar`, ohne Git-Wurzel-Ermittlung). Je Distro
+     * höchstens ein Aufruf je Lauf; ohne Verweise im Katalog wird nichts befragt. Die `.env`-Zusatzdatei
+     * (Hermes) bleibt dem Einhängen vorbehalten. Einträge ohne Verweise fehlen in der Map.
+     */
+    async mcpVariablenLage(uebersicht) {
+        const ergebnis = new Map();
+        const ue = uebersicht ?? (await this.mcpUebersicht());
+        const mitVerweisen = ue.katalog.filter((k) => variablenVerweise(k.eintrag.konfig).length > 0);
+        if (mitVerweisen.length === 0)
+            return ergebnis;
+        let moegliche;
+        const umgebungen = new Map();
+        for (const k of mitVerweisen) {
+            let welten = k.eingehaengt.map((z) => wslDistroVonOrt(z.ort));
+            if (welten.length === 0) {
+                if (moegliche === undefined) {
+                    moegliche = [];
+                    for (const ziel of await this.mcpZiele()) {
+                        const mcp = this.harnessMitMcp(ziel.harness).mcp;
+                        if (mcp.ortBedienbar !== undefined && !(await mcp.ortBedienbar(ziel.ort)))
+                            continue;
+                        moegliche.push(wslDistroVonOrt(ziel.ort));
+                    }
+                }
+                welten = moegliche;
+            }
+            const verweise = variablenVerweise(k.eintrag.konfig);
+            const befunde = [];
+            // Lokale Welt zuerst, dann die Distros in der Reihenfolge ihres Auftretens.
+            const eindeutig = [...new Set(welten)].sort((a, b) => (a === undefined ? -1 : b === undefined ? 1 : 0));
+            for (const distro of eindeutig) {
+                let env = umgebungen.get(distro);
+                if (env === undefined) {
+                    env = this.mcpUmgebungDerWelt(distro);
+                    umgebungen.set(distro, env);
+                }
+                const umgebung = await env;
+                if (umgebung === undefined)
+                    befunde.push({ distro: distro, ungeprueft: true });
+                else {
+                    const fehlend = verweise.filter((v) => umgebung[v] === undefined);
+                    befunde.push(distro === undefined ? { fehlend } : { distro, fehlend });
+                }
+            }
+            ergebnis.set(k.eintrag.name, befunde);
+        }
+        return ergebnis;
+    }
     /**
      * F39: fehlende `${VAR}`-Verweise als Warnung, nie als Abbruch. Geprüft wird gegen die eigene
      * Prozess-Umgebung und, wenn die Fähigkeit eine `.env`-Datei nennt (Hermes), zusätzlich gegen sie.
@@ -404,17 +465,10 @@ export class Anwendungsfaelle {
             return undefined;
         // Ein WSL-Ziel startet claude in der Distro mit deren Umgebung, nicht mit der von Windows (E104).
         const distro = wslDistroVonOrt(ort);
-        let prozessEnv;
-        if (distro === undefined) {
-            prozessEnv = this.p.umgebung.variablen();
-        }
-        else {
-            const distroEnv = await this.p.wsl.variablen(distro).catch(() => undefined);
-            if (distroEnv === undefined) {
-                return (`hmgr konnte die Umgebung der WSL-Distro ${distro} nicht lesen; die Verweise ` +
-                    `${verweise.map((v) => '${' + v + '}').join(', ')} sind deshalb ungeprüft.`);
-            }
-            prozessEnv = distroEnv;
+        const prozessEnv = await this.mcpUmgebungDerWelt(distro);
+        if (prozessEnv === undefined) {
+            return (`hmgr konnte die Umgebung der WSL-Distro ${distro} nicht lesen; die Verweise ` +
+                `${verweise.map((v) => '${' + v + '}').join(', ')} sind deshalb ungeprüft.`);
         }
         const envPfad = faehig.mcp.envDatei?.(ort);
         const zusatzEnv = envPfad === undefined ? {} : await this.p.umgebung.envDatei(envPfad);

package/package.json

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