hmgr 0.0.28 → 0.0.30

package/dist/adapter/claude-code.js

@@ -9,6 +9,7 @@ import { LokalerZugriff } from "./dateisystem.js";
 import { gitignoreEintragen, istGitRepo } from "./gitignore.js";
 import { arbeitsverzeichnisVerbinden, heimVerbinden, nurHome } from "./heime.js";
 import { tiefGleich } from "./vergleich.js";
+import { mitZeitlimit } from "./zeitlimit.js";
 const CLAUDE_VERZEICHNIS = '.claude';
 const SKILLS_ORDNER = 'skills';
 /**
@@ -34,8 +35,8 @@ const GITIGNORE_ZEILE = '.claude/';
 /**
  * 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
- * fängt alles Übrige (beobachtet: 13 Minuten ohne Rückkehr in der GUI). SIGKILL, weil die
- * CLI SIGTERM überleben kann.
+ * fängt alles Übrige (beobachtet: 13 Minuten ohne Rückkehr in der GUI), selbst gesetzt statt
+ * über die spawn-Option (E98, siehe `mitZeitlimit`).
  *
  * `spawn` kommt von cross-spawn, nicht aus node:child_process (E65/B7): unter Windows ist die
  * npm-installierte `claude` ein `.cmd`-Shim, und Node startet `.cmd`/`.bat` seit dem Fix zu
@@ -48,9 +49,8 @@ export const claudeAusfuehrer = (args, cwd) => new Promise((aufloesen) => {
     const kind = spawn('claude', args, {
         ...(cwd === undefined ? {} : { cwd }),
         stdio: ['ignore', 'pipe', 'pipe'],
-        timeout: 120_000,
-        killSignal: 'SIGKILL',
     });
+    mitZeitlimit(kind, 120_000);
     let stdout = '';
     let stderr = '';
     // `!`, weil cross-spawn nur den allgemeinen ChildProcess-Typ mit nullbaren Strömen kennt;

package/dist/adapter/git.js

@@ -121,10 +121,39 @@ async function dateienAufPlatte(wurzel, unter = '') {
     }
     return dateien;
 }
+/**
+ * Wartezeiten zwischen den Versuchen bei belegter git-Sperre (E99): 5 Versuche, zusammen rund 3 s.
+ * Tests übergeben kürzere über den Konstruktor.
+ */
+export const SPERRE_WARTEZEITEN_MS = [200, 400, 800, 1600];
+/** Meldung, mit der git eine belegte Sperrdatei anzeigt (E99). */
+const SPERRE_BELEGT = /Unable to create '[^']+\.lock': File exists/;
 export class GitQuellen {
     wurzel;
-    constructor(wurzel) {
+    sperreWartezeitenMs;
+    constructor(wurzel, optionen = {}) {
         this.wurzel = wurzel;
+        this.sperreWartezeitenMs = optionen.sperreWartezeitenMs ?? SPERRE_WARTEZEITEN_MS;
+    }
+    /**
+     * Wiederholt einen git-Aufruf, wenn eine fremde Sperre ihn blockiert (E99): GUI-Aktionen und der
+     * Start-Lauf rufen git parallel auf, und git bricht bei `….lock: File exists` sofort ab. Nur
+     * diese Meldung wird wiederholt, jeder andere Fehler gilt sofort. Nach dem letzten Versuch bleibt
+     * die bisherige Fehlermeldung. hmgr löscht fremde Sperren nie, auch keine verwaisten.
+     */
+    async mitSperrWiederholung(aufruf) {
+        for (let versuch = 0;; versuch++) {
+            try {
+                return await aufruf();
+            }
+            catch (fehler) {
+                const wartezeit = this.sperreWartezeitenMs[versuch];
+                const meldung = fehler instanceof Error ? fehler.message : String(fehler);
+                if (wartezeit === undefined || !SPERRE_BELEGT.test(meldung))
+                    throw fehler;
+                await new Promise((fertig) => setTimeout(fertig, wartezeit));
+            }
+        }
     }
     /**
      * stdin ist zu und git darf nicht nach Zugangsdaten fragen, sonst hängt ein wartender Aufruf
@@ -132,6 +161,9 @@ export class GitQuellen {
      * als dort, ein erster Clone über ein langsames Netz braucht Zeit.
      */
     async git(args, cwd) {
+        return await this.mitSperrWiederholung(() => this.gitEinmal(args, cwd));
+    }
+    async gitEinmal(args, cwd) {
         return await new Promise((erfuellen, ablehnen) => {
             const kind = spawn('git', args, {
                 cwd,
@@ -155,6 +187,9 @@ export class GitQuellen {
     }
     /** Wie `git`, aber mit Text auf stdin und Bytes als Ergebnis: `execFile` kennt keine Eingabe. */
     async gitMitEingabe(args, cwd, eingabe) {
+        return await this.mitSperrWiederholung(() => this.gitMitEingabeEinmal(args, cwd, eingabe));
+    }
+    async gitMitEingabeEinmal(args, cwd, eingabe) {
         return await new Promise((erfuellen, ablehnen) => {
             const kind = spawn('git', args, { cwd, timeout: 300_000, killSignal: 'SIGKILL' });
             const stuecke = [];

package/dist/adapter/wsl.js

@@ -4,13 +4,15 @@
 import spawn from 'cross-spawn';
 import path from 'node:path';
 import { WslBrueckeFehlgeschlagen } from "../kern/modell.js";
+import { mitZeitlimit } from "./zeitlimit.js";
 /**
  * Standard-Ausführer: `wsl.exe` vom PATH, über cross-spawn wie die claude-CLI (E65/B7). stdin ist
- * zu, sonst hängt eine Distro, die auf Eingabe wartet; der Timeout fängt alles Übrige. Ein
+ * zu, sonst hängt eine Distro, die auf Eingabe wartet; der Timeout (E98, `mitZeitlimit`) fängt alles Übrige. Ein
  * Fehlschlag wird zum Code, nicht zur Ausnahme.
  */
 export const wslAusfuehrer = (args) => new Promise((aufloesen) => {
-    const kind = spawn('wsl.exe', args, { stdio: ['ignore', 'pipe', 'pipe'], timeout: 60_000, killSignal: 'SIGKILL' });
+    const kind = spawn('wsl.exe', args, { stdio: ['ignore', 'pipe', 'pipe'] });
+    mitZeitlimit(kind, 60_000);
     const teile = [];
     const fehlerTeile = [];
     kind.stdout.on('data', (d) => teile.push(d));

package/dist/adapter/zeitlimit.js

@@ -0,0 +1,14 @@
+/**
+ * Zeitlimit für einen mit cross-spawn gestarteten Prozess (E98). Statt der spawn-Option `timeout`
+ * setzen wir den Wecker selbst: Node räumt dessen Timer im `exit`-Handler ab, cross-spawn ersetzt
+ * unter Windows aber das `exit` eines nicht gefundenen Programms durch ein `error`. Der Timer
+ * bliebe stehen und hielte den Prozess bis zum Ablauf am Leben (gemessen: 120 s ohne `claude`).
+ * Abgeräumt wird deshalb bei `close` und bei `error`. Bei Ablauf SIGKILL, weil CLIs SIGTERM
+ * überleben können; der Aufrufer sieht dann wie bisher `close` mit Code `null`.
+ */
+export function mitZeitlimit(kind, ms) {
+    const wecker = setTimeout(() => kind.kill('SIGKILL'), ms);
+    const abraeumen = () => clearTimeout(wecker);
+    kind.once('close', abraeumen);
+    kind.once('error', abraeumen);
+}

package/dist/gui/hmgr-cli.js

@@ -4,6 +4,7 @@
 import { homedir } from 'node:os';
 import path from 'node:path';
 import spawn from 'cross-spawn';
+import { mitZeitlimit } from "../adapter/zeitlimit.js";
 import { versionLesen } from "../kern/version.js";
 /**
  * Zeigt der aufgelöste Treffer auf die laufende GUI selbst (E97)? Deren Electron-exe heißt ebenfalls
@@ -25,8 +26,6 @@ export function istEigeneGui(aufgeloest, execPath, plattform) {
 export function cliSpawnOptionen(heim = homedir()) {
     return {
         stdio: ['ignore', 'pipe', 'ignore'],
-        timeout: 10_000,
-        killSignal: 'SIGKILL',
         cwd: heim,
     };
 }
@@ -45,7 +44,7 @@ function aufgeloesterPfad(optionen) {
  *
  * `spawn` von cross-spawn wie im claude-Adapter (E65/B7): unter Windows ist die npm-installierte
  * `hmgr` ein `.cmd`-Shim, das Node seit dem Fix zu CVE-2024-27980 ohne Umweg über cmd.exe nicht
- * mehr startet. stdin zu und ein Timeout, damit nichts hängen bleibt — ein Timeout liefert `fehlt`
+ * mehr startet. stdin zu und ein Timeout (E98, `mitZeitlimit`), damit nichts hängen bleibt — ein Timeout liefert `fehlt`
  * (cross-spawn beendet den Prozess dann mit `close` und `null`-Code samt Signal, kein `error`).
  */
 export function hmgrCliVersion() {
@@ -63,6 +62,7 @@ export function hmgrCliVersion() {
                 return melden({ art: 'fehlt' });
             }
             const kind = spawn('hmgr', ['--version'], optionen);
+            mitZeitlimit(kind, 10_000);
             let stdout = '';
             kind.stdout.on('data', (stueck) => (stdout += stueck));
             kind.on('error', () => melden({ art: 'fehlt' }));

package/package.json

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