hmgr 0.0.34 → 0.0.36

package/dist/adapter/claude-code.js

@@ -22,6 +22,8 @@ function distroOrt(distro) {
     return { art: 'home', heim: `wsl:${distro}` };
 }
 const GITIGNORE_ZEILE = '.claude/';
+/** Wie lange „keine claude-CLI erreichbar" gilt, bevor erneut gefragt wird (E103). */
+const ERREICHBARKEIT_NEGATIV_MS = 60_000;
 /**
  * Standard-Ausführer: `claude` vom PATH. Ein Fehlschlag wird zum Code, nicht zur Ausnahme.
  * stdin ist zu, sonst hängt eine CLI, die auf Eingabe wartet, den ganzen Ablauf; der Timeout
@@ -336,6 +338,10 @@ class ClaudeMcp {
     ebenen() {
         return ['home', 'arbeitsverzeichnis'];
     }
+    /** Ob am Ort eine claude-CLI antwortet (E103): ohne sie bringt Einhängen oder Aushängen dort nichts. */
+    async ortBedienbar(ort) {
+        return await this.harness.cliErreichbar(ort);
+    }
     hinweisNachAenderung() {
         return 'Claude Code übernimmt die Änderung mit der nächsten Sitzung.';
     }
@@ -508,7 +514,12 @@ export class ClaudeCode {
      */
     plugins;
     mcp;
-    /** Ob die claude-CLI antwortet, je Welt einmal je Lauf: Schlüssel '' für Windows, sonst die Distro. */
+    /**
+     * Ob die claude-CLI antwortet, je Welt: Schlüssel '' für Windows, sonst die Distro. Ein positives
+     * Ergebnis gilt für die Lebenszeit des Adapters, ein negatives verfällt nach 60 Sekunden (E103), damit
+     * eine laufende GUI eine inzwischen installierte claude findet. Solange `bis` fehlt (die Antwort steht
+     * aus) oder noch nicht erreicht ist, teilen sich parallele Anfragen das Versprechen.
+     */
     erreichbarkeit = new Map();
     /**
      * `heime` sagt, wo die Homedirs liegen (E78): das primäre und, seit F87, zusätzliche in einer
@@ -536,6 +547,7 @@ export class ClaudeCode {
                         bruecken.set(distro, (b = new WslBruecke(distro)));
                     return b;
                 }),
+            jetzt: wsl?.jetzt ?? (() => Date.now()),
             distros: wsl?.distros ??
                 (async () => this.heime
                     .zusaetzliche(this.name)
@@ -551,18 +563,32 @@ export class ClaudeCode {
     bruecke(distro) {
         return this.wsl.bruecke(distro);
     }
-    /** Ob an diesem Ort eine claude-CLI antwortet (`claude --version`), je Welt einmal je Lauf. */
+    /**
+     * Ob an diesem Ort eine claude-CLI antwortet (`claude --version`), je Welt: ein „ja" bleibt, ein
+     * „nein" gilt 60 Sekunden (E103).
+     */
     async erreichbar(ort) {
         const schluessel = wslDistroVonOrt(ort) ?? '';
-        let versprechen = this.erreichbarkeit.get(schluessel);
-        if (versprechen === undefined) {
-            const cli = schluessel === '' ? this.ausfuehrer : this.ausfuehrerFuer(ort);
-            versprechen = cli(['--version'])
+        const bekannt = this.erreichbarkeit.get(schluessel);
+        if (bekannt !== undefined && (bekannt.bis === undefined || this.wsl.jetzt() < bekannt.bis))
+            return await bekannt.versprechen;
+        const cli = schluessel === '' ? this.ausfuehrer : this.ausfuehrerFuer(ort);
+        const eintrag = {
+            versprechen: cli(['--version'])
                 .then(({ code }) => code === 0)
-                .catch(() => false);
-            this.erreichbarkeit.set(schluessel, versprechen);
-        }
-        return await versprechen;
+                .catch(() => false)
+                .then((ok) => {
+                if (!ok)
+                    eintrag.bis = this.wsl.jetzt() + ERREICHBARKEIT_NEGATIV_MS;
+                return ok;
+            }),
+        };
+        this.erreichbarkeit.set(schluessel, eintrag);
+        return await eintrag.versprechen;
+    }
+    /** Ob an diesem Ort eine claude-CLI antwortet, ohne zu werfen (E103): für Plätze, die ohne CLI nichts bringen. */
+    async cliErreichbar(ort) {
+        return await this.erreichbar(ort);
     }
     /** Wirft `ClaudeCliNichtErreichbar`, wenn an diesem Ort keine claude-CLI antwortet (E100). */
     async cliPruefen(ort) {
@@ -578,8 +604,10 @@ export class ClaudeCode {
      * Windows durchläuft — oder, wenn dort keine CLI liegt, sobald sie in der Distro eines
      * eingetragenen WSL-Orts antwortet. Die Distros werden erst dann befragt, nacheinander bis zur
      * ersten Antwort, damit ein Rechner mit Windows-claude keinen wsl.exe-Start zahlt. Jede Welt wird
-     * einmal je Lauf geprüft; in der GUI kommt ein später eingetragener WSL-Ort beim nächsten Aufruf
-     * dazu, ohne die schon geprüften erneut zu fragen.
+     * einmal geprüft (ein „ja" bleibt); in der GUI kommt ein später eingetragener WSL-Ort beim nächsten Aufruf
+     * dazu, ohne die schon geprüften erneut zu fragen. Ein negatives Ergebnis verfällt nach 60 Sekunden
+     * (E103): ein erneuter Aufruf danach fragt noch einmal und setzt die Fähigkeiten, sobald claude
+     * inzwischen da ist.
      */
     async vorhanden() {
         const primaer = this.heime.primaer(this.name);

package/dist/adapter/wsl.js

@@ -51,6 +51,33 @@ export function wslClaudeAusfuehrer(distro, ausfuehren) {
         return { stdout: ausgabe.toString('utf8'), code };
     };
 }
+/** Die Zeile, die dem `env` im Umgebungs-Skript vorausgeht; was davor steht (MOTD, Profil-Echo), ist Rauschen. */
+export const UMGEBUNG_MARKER = '__HMGR_ENV__';
+/**
+ * Liest die Umgebung einer Distro (E104): die Login-Shell des Benutzers, interaktiv und als Login
+ * (`-lic`), wie sie im Terminal der Distro läuft und `~/.profile` wie `~/.bashrc` liest. Die Shell
+ * kann eine MOTD vor die eigene Ausgabe schreiben, deshalb steht der Marker davor.
+ */
+export const UMGEBUNG_IN_WSL_SKRIPT = 's=$(getent passwd "$(id -un)" 2>/dev/null | cut -d: -f7); [ -x "$s" ] || s=/bin/sh; ' +
+    `exec "$s" -lic 'echo ${UMGEBUNG_MARKER}; env'`;
+/**
+ * Die Variablen aus der Ausgabe von `UMGEBUNG_IN_WSL_SKRIPT`: nur was nach der letzten Markerzeile
+ * steht, Zeilen `NAME=wert` (Wert darf `=` enthalten). Fortsetzungszeilen mehrzeiliger Werte passen
+ * nicht auf das Namensmuster und fallen weg. Ohne Marker: `undefined`.
+ */
+export function umgebungLesen(text) {
+    const zeilen = text.split(/\r?\n/);
+    const ab = zeilen.map((z) => z.trim()).lastIndexOf(UMGEBUNG_MARKER);
+    if (ab === -1)
+        return undefined;
+    const variablen = {};
+    for (const zeile of zeilen.slice(ab + 1)) {
+        const treffer = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/.exec(zeile);
+        if (treffer !== null)
+            variablen[treffer[1]] = treffer[2];
+    }
+    return variablen;
+}
 /**
  * Eine wsl.exe-eigene Ausgabe als Text (E78, gemessen): UTF-16LE, mit BOM. Node kennt die Kodierung
  * als „utf16le"; die BOM bleibt beim Dekodieren als `\uFEFF` stehen und wird hier entfernt. Ein
@@ -166,6 +193,14 @@ export class WslBruecke {
             return null;
         return { wurzel, relativerPfad: (prefix ?? '').replace(/\/+$/, '') };
     }
+    /**
+     * Die Umgebung, die eine im Terminal der Distro gestartete claude sähe (E104); `undefined`, wenn
+     * sie nicht lesbar ist (Code ≠ 0, kein Marker, Zeitüberschreitung).
+     */
+    async variablen() {
+        const { text, code } = await this.exec(['sh', '-c', UMGEBUNG_IN_WSL_SKRIPT]);
+        return code === 0 ? umgebungLesen(text) : undefined;
+    }
     /** Dasselbe, aber ein Fehlschlag ist kein Fehler: `undefined`. Für lesende Abfragen. */
     async shWeich(skript) {
         const { ausgabe, code } = await this.ausfuehren(['-d', this.distro, '/bin/sh', '-c', skript]);

package/dist/cli/hilfe.js

@@ -430,7 +430,8 @@ mit der nächsten Sitzung, Hermes lädt seine config.yaml selbst nach, dafür gi
 
 Fehlende \${VAR}-Verweise beim Einhängen sind kein Abbruch, nur eine Warnung (F39): hmgr kann nicht
 wissen, was die Shell beim Start des Harness setzt. Geprüft wird gegen die eigene Prozess-Umgebung
-und, bei einem Hermes-Ziel, zusätzlich gegen <hermes-home>/.env.
+und, bei einem Hermes-Ziel, zusätzlich gegen <hermes-home>/.env. Bei einem Ziel in WSL gilt statt der
+Prozess-Umgebung die der Distro, wie ihre Login-Shell sie im Terminal setzt (Login-Shell, interaktiv).
 
 Schalter (add, remove und migrate):
   --harness <name>    claude-code oder hermes, Standard claude-code

package/dist/cli/main.js

@@ -63,6 +63,8 @@ export function bauen(umgebung, optionen = {}) {
     // der Bridge, `mcp add-json` startet in der Distro eine ganze Node-Laufzeit.
     const windowsClaude = optionen.claudeAusfuehrer ?? claudeAusfuehrer;
     const wslClaudeAusfuehren = optionen.wslAusfuehrer ?? wslAusfuehrerMit(120_000);
+    // Die Umgebung der Distro (E104): eine interaktive Login-Shell, die sich nicht melden darf.
+    const wslUmgebungAusfuehren = optionen.wslAusfuehrer ?? wslAusfuehrerMit(15_000);
     const claudeFuerOrt = (ort) => {
         const distro = wslDistroVonOrt(ort);
         return distro === undefined ? windowsClaude : wslClaudeAusfuehrer(distro, wslClaudeAusfuehren);
@@ -99,6 +101,7 @@ export function bauen(umgebung, optionen = {}) {
             distros: async () => await wslDistros(wslAusfuehren),
             home: async (distro) => await bruecke(distro).home(),
             gitWurzel: async (distro, linuxPfad) => await bruecke(distro).gitWurzel(linuxPfad),
+            variablen: async (distro) => await new WslBruecke(distro, wslUmgebungAusfuehren).variablen(),
         },
         verlauf,
     };

package/dist/gui/renderer/renderer.js

@@ -1202,6 +1202,23 @@
     var verzMcpZiele = MCP_PLAETZE.filter(function (p) {
       return p.ort.art === 'arbeitsverzeichnis' && p.ort.pfad === pfad;
     });
+    // E103: mcpPlaetze() lässt Orte weg, an denen der Harness nicht bedienbar ist (keine CLI). Hängt
+    // dort schon etwas, bleibt der Abschnitt samt Entfernen-Knopf trotzdem stehen; nur das
+    // „hinzufügen" entfällt (mcpKannAn).
+    var gesehen = {};
+    verzMcpZiele.forEach(function (p) { gesehen[zielKey(p)] = true; });
+    var vorhandene = [];
+    MCP_KATALOG.forEach(function (k) {
+      k.eingehaengt.forEach(function (z) { vorhandene.push(z); });
+      k.geteilteFundorte.forEach(function (g) { vorhandene.push(g.ziel); });
+    });
+    MCP_FREMD.forEach(function (x) { vorhandene.push(x.ziel); });
+    MCP_FREMD_GETEILT.forEach(function (x) { vorhandene.push(x.ziel); });
+    vorhandene.forEach(function (z) {
+      if (z.ort.art !== 'arbeitsverzeichnis' || z.ort.pfad !== pfad || gesehen[zielKey(z)]) return;
+      gesehen[zielKey(z)] = true;
+      verzMcpZiele.push(z);
+    });
 
     if (reihenfolge.length === 0) {
       var leer = e('div', 'leerzeile');

package/dist/kern/anwendungsfaelle.js

@@ -402,16 +402,30 @@ export class Anwendungsfaelle {
         const verweise = variablenVerweise(eintrag.konfig);
         if (verweise.length === 0)
             return undefined;
-        const prozessEnv = this.p.umgebung.variablen();
+        // 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 envPfad = faehig.mcp.envDatei?.(ort);
         const zusatzEnv = envPfad === undefined ? {} : await this.p.umgebung.envDatei(envPfad);
         const fehlend = verweise.filter((v) => !(v in prozessEnv) && !(v in zusatzEnv));
         if (fehlend.length === 0)
             return undefined;
         const mehrzahl = fehlend.length > 1;
+        const wo = distro === undefined ? 'aktuellen Umgebung' : `Umgebung der WSL-Distro ${distro} (Login-Shell, interaktiv)`;
         return (`hmgr kann nicht wissen, was die Shell beim Start des Harness setzt: ` +
             `${mehrzahl ? 'Variablen' : 'Variable'} ${fehlend.join(', ')} ${mehrzahl ? 'sind' : 'ist'} weder in der ` +
-            'aktuellen Umgebung noch in einer bekannten .env-Datei zu finden.');
+            `${wo} noch in einer bekannten .env-Datei zu finden.`);
     }
     /**
      * MCP einhängen (E61): Katalog-Eintrag an ein Ziel legen, Projekt oder global. Die Fähigkeit hängt
@@ -499,10 +513,15 @@ export class Anwendungsfaelle {
      * Die Plätze für den Einhängen-Dialog der GUI (E61-Folgerunde, F42): dieselbe Liste wie in
      * `mcpUebersicht`, aber roh, ohne den Abgleich mit Katalog-Einträgen. Die Fähigkeit hängt am
      * Adapter, nicht am Harness-Namen (E16): agents kommt nie vor, weil es `mcp` nicht implementiert.
+     * Orte, an denen der Harness nicht bedienbar ist (E103, etwa keine claude-CLI), fehlen; die
+     * Übersicht lässt sie stehen, damit vorhandene Einträge sichtbar bleiben.
      */
     async mcpPlaetze() {
         const plaetze = [];
         for (const ziel of await this.mcpZiele()) {
+            const mcp = this.harnessMitMcp(ziel.harness).mcp;
+            if (mcp.ortBedienbar !== undefined && !(await mcp.ortBedienbar(ziel.ort)))
+                continue;
             const wurzel = await this.mcpGitWurzelFuer(this.harnessMitMcp(ziel.harness).mcp, ziel);
             plaetze.push(wurzel === null ? ziel : { ...ziel, gitWurzel: wurzel });
         }

package/package.json

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