hmgr 0.0.4 → 0.0.6

package/dist/gui/icons.js

@@ -0,0 +1,114 @@
+// Quellen-Icon im Main-Prozess (E60): Besitzer-Avatar bei GitHub/Gitea, sonst Favicon, sonst
+// generisch. Lädt nur hier (nie im Renderer, contextIsolation lässt dort ohnehin kein fetch mit
+// Netzzugriff zu, das hier ist reine Main-Prozess-Politik), cached als data-URL auf Platte
+// unterhalb von HMGR_HOME (Aufrufer reicht das Verzeichnis rein), damit Tests und der Smoke-Test
+// nie ein echtes Verzeichnis anfassen. Ein Fehlschlag wird mitgecacht, aber nur für einen Tag: ein
+// Treffer gilt für immer, ein Fehlschlag verfällt, sonst bliebe es bei generischen Symbolen für
+// jeden, der beim ersten Start ohne Netz war. „lokal" und jede unbekannte Adresse ergeben sofort null.
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { urlOrt } from "../kern/quelle-ort.js";
+const STANDARD_TIMEOUT_MS = 5000;
+/**
+ * Ein Fehlschlag hält einen Tag, ein Treffer hält für immer. Ohne Verfall bekäme jeder, der beim
+ * ersten Start offline war, dauerhaft nur generische Symbole — der Cache soll das Netz schonen,
+ * nicht ein einmaliges „gerade kein Netz" festschreiben.
+ */
+const FEHLSCHLAG_HALTBARKEIT_MS = 24 * 60 * 60 * 1000;
+/**
+ * Obergrenze für ein Icon. Ein Avatar oder Favicon ist ein paar Kilobyte groß; alles darüber ist
+ * kein Symbol mehr und hätte als data-URL nichts im Cache und in der Ansicht verloren.
+ */
+const MAX_ICON_BYTES = 512 * 1024;
+/**
+ * Kandidaten-URLs für den Besitzer-Avatar, in Versuchsreihenfolge (F35): GitHub liefert den Avatar
+ * über einen eigenen Pfad, jeder andere http(s)-Host bekommt zuerst den mutmaßlichen Avatar-Pfad
+ * versucht (das bedient auch Gitea), dann sein Favicon.
+ */
+export function iconKandidaten(ort) {
+    if (ort.host === 'github.com')
+        return [`https://github.com/${ort.besitzer}.png?size=40`];
+    return [`https://${ort.host}/${ort.besitzer}.png`, `https://${ort.host}/favicon.ico`];
+}
+function cacheDateiname(schluessel) {
+    return `${createHash('sha256').update(schluessel).digest('hex')}.txt`;
+}
+/**
+ * Die Zeitüberschreitung umfasst auch das Lesen des Rumpfs, nicht nur den Kopf: ein Server, der die
+ * Kopfzeilen sofort schickt und dann tröpfelt, würde den Aufruf sonst unbegrenzt hängen lassen.
+ * Deshalb läuft die ganze Arbeit unter demselben Signal, der Wecker fällt erst danach.
+ */
+async function mitTimeout(arbeit, timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await arbeit(controller.signal);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function alsDataUrl(antwort) {
+    if (!antwort.ok)
+        return undefined;
+    const typ = antwort.headers.get('content-type') ?? '';
+    if (!typ.startsWith('image/'))
+        return undefined;
+    const angekuendigt = Number(antwort.headers.get('content-length'));
+    if (Number.isFinite(angekuendigt) && angekuendigt > MAX_ICON_BYTES)
+        return undefined;
+    const puffer = Buffer.from(await antwort.arrayBuffer());
+    if (puffer.length === 0 || puffer.length > MAX_ICON_BYTES)
+        return undefined;
+    return `data:${typ.split(';')[0]};base64,${puffer.toString('base64')}`;
+}
+/**
+ * Was im Cache steht: eine data-URL (Treffer, gilt immer), oder ein Fehlschlag (leere Datei), der
+ * nur bis zu seiner Haltbarkeit gilt. Fehlt beides, muss abgefragt werden.
+ */
+async function ausCache(cachePfad) {
+    const inhalt = await readFile(cachePfad, 'utf8').catch(() => undefined);
+    if (inhalt === undefined)
+        return undefined;
+    if (inhalt.length > 0)
+        return { wert: inhalt };
+    const info = await stat(cachePfad).catch(() => undefined);
+    if (info && Date.now() - info.mtimeMs < FEHLSCHLAG_HALTBARKEIT_MS)
+        return { wert: null };
+    return undefined;
+}
+/**
+ * Icon einer Quelle als data-URL, oder null (lokale Quelle, unlesbare Adresse oder jeder
+ * Fehlschlag: Zeitüberschreitung, Netzfehler, kein Bild). Das Ergebnis – auch ein Fehlschlag –
+ * landet auf Platte, ein zweiter Aufruf für denselben Host/Besitzer fragt nicht erneut ab; ein
+ * gecachter Fehlschlag verfällt nach einem Tag und wird dann erneut versucht.
+ */
+export async function iconFuerQuelle(quelle, optionen) {
+    if (quelle.art === 'lokal')
+        return null;
+    const ort = urlOrt(quelle.url);
+    if (!ort || ort.host === 'local')
+        return null;
+    const holen = optionen.fetch ?? ((url, init) => fetch(url, init));
+    const timeoutMs = optionen.timeoutMs ?? STANDARD_TIMEOUT_MS;
+    const schluessel = `${ort.host}/${ort.besitzer}`;
+    const cachePfad = path.join(optionen.cacheVerzeichnis, cacheDateiname(schluessel));
+    const cached = await ausCache(cachePfad);
+    if (cached !== undefined)
+        return cached.wert;
+    let ergebnis;
+    for (const url of iconKandidaten(ort)) {
+        try {
+            ergebnis = await mitTimeout(async (signal) => alsDataUrl(await holen(url, { signal })), timeoutMs);
+        }
+        catch {
+            ergebnis = undefined;
+        }
+        if (ergebnis)
+            break;
+    }
+    await mkdir(optionen.cacheVerzeichnis, { recursive: true }).catch(() => undefined);
+    await writeFile(cachePfad, ergebnis ?? '', 'utf8').catch(() => undefined);
+    return ergebnis ?? null;
+}

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);
+}