hmgr 0.0.5 → 0.0.7

package/dist/gui/beobachter.js

@@ -0,0 +1,108 @@
+// Datei-Watcher für externe Änderungen (E62): main.ts verdrahtet nur, die eigentliche Logik ist
+// hier rein (kein Electron-Import), nach dem Muster von oeffnen.ts und icons.ts, damit sie ohne
+// Electron testbar ist.
+//
+// Beobachtet wird eine feste Liste von Pfaden (hmgr-Zustand, MCP-Katalog, Harness-MCP-Konfigs,
+// .env-Dateien, siehe main.ts). Zwei Eigenheiten des Dateisystems bestimmen den Aufbau, beide am
+// laufenden System gemessen (macOS 25, Node 22):
+//
+// 1. Beobachtet wird nie die Datei selbst, sondern immer ihr Elternverzeichnis mit einem Filter auf
+//    die Dateinamen darin. `fs.watch` auf eine Datei hängt am Inode und wird nach dem ersten
+//    atomaren Ersetzen (schreiben in eine Temp-Datei, dann `rename` darüber) dauerhaft taub — kein
+//    weiteres Event, weder bei erneutem `rename` noch beim Schreiben an Ort und Stelle. Genau so
+//    schreiben viele Editoren, und so wird auch `~/.claude.json` ersetzt. Ein Watcher auf das
+//    Verzeichnis überlebt das und meldet den Dateinamen mit. Nebenbei deckt er Dateien ab, die beim
+//    Start noch gar nicht existieren: tauchen sie später auf, fängt derselbe Watcher es ab.
+//
+// 2. Ein Event heißt nicht, dass sich etwas geändert hat. `claude plugin list` — das hmgr bei jedem
+//    Anzeige-Aufbau je Claude-Code-Ziel ruft — ersetzt `~/.claude.json` jedes Mal per `rename`, mit
+//    unverändertem Inhalt. Ohne Gegenmaßnahme entstünde daraus eine Endlosschleife: Anzeige laden →
+//    Datei ersetzt → Watcher feuert → Anzeige laden. Darum stößt der Watcher erst an, wenn sich der
+//    Inhalt mindestens einer beobachteten Datei gegenüber dem letzten Stand wirklich unterscheidet.
+//
+// Fehlt das Elternverzeichnis, bleibt der Pfad unbeobachtet, bis ihn der nächste Fokus-Reload (E62)
+// ohnehin erfasst. Mehrere Events in kurzer Folge (ein Editor schreibt beim Speichern oft mehrfach,
+// ein `rename` meldet mehrere Events) lösen genau einen Callback aus: jedes Event verschiebt einen
+// Timer um `entprellenMs` nach hinten, erst danach wird verglichen.
+import { readFileSync, watch } from 'node:fs';
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+const STANDARD_ENTPRELLEN_MS = 400;
+/** Marke für eine Datei, die es (noch) nicht gibt — unterscheidbar von jedem echten Inhalt. */
+const FEHLT = 'fehlt';
+/** Fingerabdruck des Inhalts. Unlesbar (fehlend, keine Rechte) zählt als `FEHLT`, nicht als Änderung. */
+function fingerabdruck(pfad) {
+    try {
+        return createHash('sha256').update(readFileSync(pfad)).digest('hex');
+    }
+    catch {
+        return FEHLT;
+    }
+}
+/**
+ * Beobachtet `pfade` auf inhaltliche Änderungen und ruft `callback` entprellt auf. Doppelte Pfade
+ * werden nur einmal beobachtet, Pfade im selben Verzeichnis teilen sich einen Watcher.
+ */
+export function beobachten(pfade, callback, optionen = {}) {
+    const entprellenMs = optionen.entprellenMs ?? STANDARD_ENTPRELLEN_MS;
+    const watcher = [];
+    let timer;
+    let geschlossen = false;
+    const eindeutige = [...new Set(pfade)];
+    const stand = new Map(eindeutige.map((p) => [p, fingerabdruck(p)]));
+    /** Zieht den Stand nach und sagt, ob sich dabei etwas geändert hat. */
+    function hatSichGeaendert() {
+        let geaendert = false;
+        for (const pfad of eindeutige) {
+            const neu = fingerabdruck(pfad);
+            if (stand.get(pfad) !== neu) {
+                stand.set(pfad, neu);
+                geaendert = true;
+            }
+        }
+        return geaendert;
+    }
+    function anstossen() {
+        if (geschlossen)
+            return;
+        if (timer !== undefined)
+            clearTimeout(timer);
+        timer = setTimeout(() => {
+            timer = undefined;
+            if (geschlossen)
+                return;
+            if (hatSichGeaendert())
+                callback();
+        }, entprellenMs);
+    }
+    // Je Verzeichnis ein Watcher, der die dort gesuchten Dateinamen kennt.
+    const jeVerzeichnis = new Map();
+    for (const pfad of eindeutige) {
+        const verzeichnis = path.dirname(pfad);
+        const namen = jeVerzeichnis.get(verzeichnis) ?? new Set();
+        namen.add(path.basename(pfad));
+        jeVerzeichnis.set(verzeichnis, namen);
+    }
+    for (const [verzeichnis, namen] of jeVerzeichnis) {
+        try {
+            watcher.push(watch(verzeichnis, (_ereignis, geaenderterName) => {
+                // Ohne Namen (kommt vor, je nach Plattform) wird konservativ angestoßen; der
+                // Inhaltsvergleich entscheidet ohnehin.
+                if (geaenderterName === null || namen.has(path.basename(geaenderterName)))
+                    anstossen();
+            }));
+        }
+        catch {
+            // Das Verzeichnis fehlt: diese Pfade bleiben unbeobachtet (siehe Kommentar oben).
+        }
+    }
+    return {
+        close() {
+            geschlossen = true;
+            if (timer !== undefined)
+                clearTimeout(timer);
+            for (const w of watcher)
+                w.close();
+        },
+    };
+}

package/dist/gui/login-pfad.js

@@ -0,0 +1,120 @@
+// Ermittelt den PATH einer Login-Shell des Nutzers (F47=O2). Grund: die gepackte hmgr.app startet
+// aus dem Finder mit dem macOS-Minimal-PATH (/usr/bin:/bin:/usr/sbin:/sbin), darin fehlt z. B.
+// ~/.local/bin mit der claude-CLI (E63). Reine Funktion, ohne Electron, nach dem Muster von
+// oeffnen.ts: main.ts ruft sie beim Start und übernimmt nur process.env.PATH.
+//
+// Unter Windows unterbleibt die Ermittlung ganz (E67): dort erbt ein aus dem Startmenü gestarteter
+// Prozess den vollen Benutzer- und System-PATH aus der Registry, es gibt keine Lücke zu schließen,
+// und eine Login-Shell im POSIX-Sinn gibt es nicht.
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+/** Zeitgrenze für die Shell. Gemessen auf picasso: `zsh -i -l -c` braucht ~2,0 s, das Doppelte
+    als Puffer reicht; wird sie überschritten, bleibt der PATH eben unverändert. */
+export const ZEITGRENZE_MS = 5_000;
+/**
+ * Standard-Ausführer: die angegebene Shell, stdin zu (sonst kann sie an einem Prompt hängen),
+ * stderr verworfen. Ein Fehlschlag wird zum Code, nicht zur Ausnahme — die PATH-Ermittlung darf
+ * die App nie zum Absturz bringen.
+ *
+ * Eigener Wecker statt der `timeout`-Option von `spawn`: die killt zwar die Shell, aber `close`
+ * feuert erst, wenn auch alle Erben die stdout-Pipe losgelassen haben — eine interaktive Shell
+ * kann Hintergrundprozesse hinterlassen. Der Wecker löst unabhängig davon auf, damit dieser Aufruf
+ * unter keinen Umständen länger als `ZEITGRENZE_MS` offen bleibt. `unref`, damit ein laufender
+ * Wecker das Beenden des Prozesses nicht aufhält.
+ */
+export const shellAusfuehrer = (shell, args) => new Promise((aufloesen) => {
+    let erledigt = false;
+    const beenden = (ergebnis) => {
+        if (erledigt)
+            return;
+        erledigt = true;
+        clearTimeout(wecker);
+        aufloesen(ergebnis);
+    };
+    const kind = spawn(shell, args, { stdio: ['ignore', 'pipe', 'ignore'] });
+    const wecker = setTimeout(() => {
+        kind.kill('SIGKILL');
+        beenden({ stdout: '', code: 1 });
+    }, ZEITGRENZE_MS);
+    wecker.unref();
+    let stdout = '';
+    kind.stdout.on('data', (d) => (stdout += d));
+    kind.on('error', () => beenden({ stdout: '', code: 1 }));
+    kind.on('close', (code) => beenden({ stdout, code: code ?? 1 }));
+});
+/**
+ * Liefert den PATH einer interaktiven Login-Shell des Nutzers, oder `undefined` bei Fehler,
+ * Zeitüberschreitung oder unplausibler Ausgabe. Shell aus `process.env.SHELL`, Fallback `/bin/zsh`
+ * (macOS-Default).
+ *
+ * `-i` ist nötig, nicht bequem: zsh liest `~/.zshrc` nur interaktiv, `-l` allein nur
+ * `~/.zshenv`/`~/.zprofile`/`~/.zlogin`. Wer wie auf picasso gar kein `~/.zprofile` hat und alle
+ * PATH-Erweiterungen in `~/.zshrc` stehen hat, bekäme mit `-l` allein nur das Ergebnis von
+ * `path_helper` zurück — also genau nicht `~/.local/bin` mit der claude-CLI, um die es hier geht
+ * (gemessen 2026-09-05: `-l` ohne `-i` liefert dort kein `~/.local/bin`, `-i -l` liefert es).
+ * Das Hänge-Risiko einer interaktiven Shell fängt der Ausführer ab: stdin zu und harte Zeitgrenze.
+ *
+ * Der Marker trennt den PATH von allem, was eine gesprächige `~/.zshrc` vorher auf stdout schreibt
+ * (Begrüßung, Versionshinweis, Prompt-Framework) — ohne ihn landete das Geschwätz im ersten
+ * PATH-Eintrag. Alles vor dem letzten Marker wird verworfen; fehlt er, gilt die Ausgabe als
+ * unbrauchbar.
+ */
+export const MARKER = '__hmgr_path__';
+export async function pathAusLoginShellErmitteln(ausfuehrer = shellAusfuehrer) {
+    const shell = process.env.SHELL && process.env.SHELL.trim() !== '' ? process.env.SHELL : '/bin/zsh';
+    const { stdout, code } = await ausfuehrer(shell, ['-i', '-l', '-c', `printf %s%s '${MARKER}' "$PATH"`]);
+    if (code !== 0)
+        return undefined;
+    const ab = stdout.lastIndexOf(MARKER);
+    if (ab === -1)
+        return undefined;
+    const pfad = stdout.slice(ab + MARKER.length).trim();
+    if (pfad === '' || !pfad.includes('/'))
+        return undefined;
+    return pfad;
+}
+/**
+ * Führt den Login-PATH vor den bestehenden PATH: neue Einträge zuerst, danach der bisherige PATH,
+ * Duplikate raus (erstes Vorkommen zählt). So verliert die App nie einen Eintrag aus dem
+ * bisherigen PATH, gewinnt aber die zusätzlichen Pfade der Login-Shell. Kein Voll-Env-Import
+ * anderer Variablen — nur der PATH wird übernommen, um Überraschungen zu vermeiden.
+ *
+ * Getrennt wird an `path.delimiter`, nicht fest an ':' (E67): unter Windows ist der Trenner ';',
+ * und ein hart verdrahteter Doppelpunkt zerlegte dort `C:\Windows;C:\Git\cmd` in „C", „\Windows;C"
+ * und „\Git\cmd" — der PATH wäre zerstört, sobald ein Laufwerksbuchstabe doppelt vorkommt und die
+ * Duplikatsprüfung zuschlägt. Aufgerufen wird die Funktion unter Windows zwar nicht mehr
+ * (`loginPathUebernehmen` steigt dort vorher aus), sie soll aber für sich genommen richtig sein.
+ * Der Trenner ist ein Parameter, damit das auf jedem Rechner prüfbar ist.
+ */
+export function pathZusammenfuehren(bisherigerPath, loginPath, trenner = path.delimiter) {
+    const eintraege = [...loginPath.split(trenner), ...(bisherigerPath ?? '').split(trenner)].filter((eintrag) => eintrag !== '');
+    const gesehen = new Set();
+    const ergebnis = [];
+    for (const eintrag of eintraege) {
+        if (gesehen.has(eintrag))
+            continue;
+        gesehen.add(eintrag);
+        ergebnis.push(eintrag);
+    }
+    return ergebnis.join(trenner);
+}
+/**
+ * Ermittelt den Login-PATH und setzt ihn (vorangestellt) auf `process.env.PATH`. Bei Fehler,
+ * Timeout oder leerer/unplausibler Ausgabe bleibt `process.env.PATH` unverändert — dieser Aufruf
+ * darf die App nie am Start hindern.
+ *
+ * Unter Windows passiert nichts (E67). Zwei Gründe, jeder für sich ausreichend: dort gibt es keine
+ * Login-Shell im POSIX-Sinn, `$SHELL` ist normalerweise gar nicht gesetzt und der Aufruf liefe
+ * gegen das nicht vorhandene `/bin/zsh` ins Leere; wo `$SHELL` doch gesetzt ist (Git-Bash- und
+ * MSYS-Umgebungen setzen es), käme ein POSIX-PATH mit ':' als Trenner zurück und würde dem echten
+ * Windows-PATH vorangestellt — kein Gewinn, aber ein Risiko. Die Plattform ist ein Parameter, damit
+ * der Ausstieg auf jedem Rechner prüfbar ist.
+ */
+export async function loginPathUebernehmen(ausfuehrer = shellAusfuehrer, plattform = process.platform) {
+    if (plattform === 'win32')
+        return;
+    const loginPath = await pathAusLoginShellErmitteln(ausfuehrer);
+    if (loginPath === undefined)
+        return;
+    process.env.PATH = pathZusammenfuehren(process.env.PATH, loginPath);
+}