kimal3 0.2.6 → 0.2.7

package/dist/kimal3.js

@@ -32,6 +32,119 @@ import { projektListe } from "./befehle/projekt-liste.js";
 import { projektNeu } from "./befehle/projekt-neu.js";
 import { skillDatei, skillInstall } from "./befehle/skill-install.js";
 import { wache, wacheSchalten } from "./befehle/wache.js";
+/** Eine Meldung pro Programmlauf -- s. "Einmal-Riegel" im Block darunter. */
+let schonGemeldet = false;
+/**
+ * Die gekappte Leitung macht keinen Laerm mehr (D-27).
+ *
+ * 🔴 WARUM DAS HIER STEHT UND NICHT IN `endeMitHinweis`: Ein Schreibfehler auf
+ * STDOUT/STDERR kommt NICHT als Wurf zurueck, den ein try/catch faengt --
+ * er kommt als `'error'`-EREIGNIS auf dem Kanal selbst. Ohne angemeldeten
+ * Empfaenger behandelt Node ein unbehandeltes `'error'`-Ereignis als
+ * Programmabbruch, egal WELCHE Zeile gerade schreibt. Und geschrieben wird
+ * schon lange vor `endeMitHinweis` -- `haupt()` gibt bei `--version`, `--help`
+ * und jedem Befehl selbst aus. Der Empfaenger muss deshalb angemeldet sein,
+ * BEVOR die erste Zeile faellt: hier, auf Modulebene, noch vor jedem Aufruf.
+ *
+ * Gemessen (`npm run check:cli-live`, Fall a): Leitet ein Kunde
+ * `kimal3 --version | head -1`, schliesst `head` die Leitung, sobald es seine
+ * eine Zeile hat -- der naechste Schreibversuch von kimal3 trifft auf einen
+ * toten Empfaenger. Ohne diesen Empfaenger hier wirft das eine rote
+ * Stapelspur auf den Bildschirm, fuer einen Befehl, der laengst fertig war.
+ *
+ * ⚠️ EPIPE SCHLUCKEN, ABER NICHT ALLES (Technische Notiz der Aufgabe): Eine
+ * gekappte Leitung ist kein Fehler, den man MELDEN koennte -- der Empfaenger
+ * ist weg, niemand liest eine Meldung. Jeder ANDERE Kanalfehler ist einer und
+ * darf nicht stillschweigend verschwinden -- sonst truege ein Fehlerfall
+ * denselben Namen wie ein Erfolgsfall (vgl. die Regel zu `bestaetigungen-
+ * Aktivieren` in der Projekt-CLAUDE.md). Deshalb wird der Rueckgabewert auf 1
+ * gesetzt -- und die Meldung geht, wenn ueberhaupt, auf den FEHLERkanal.
+ *
+ * 🔴 UND DIE MELDUNG GEHT NIE IN DEN DATENKANAL -- die Ungleichheit der zwei
+ * Kanaele IST der Bauplan, keine Ausnahme (Befund W-1a der Gesamt-Durchsicht,
+ * 2026-09-12). Hier stand vorher "sag es auf dem JEWEILS ANDEREN Kanal", und
+ * das war fuer einen der zwei Faelle falsch:
+ *   · Bricht der DATENkanal (stdout), darf auf dem Fehlerkanal gemeldet
+ *     werden -- der ist genau dafuer da.
+ *   · Bricht der FEHLERkanal (stderr), wird NIRGENDS gemeldet. Auf stdout
+ *     liegt die Maschinenform: das JSON von `firma daten` und die JSON-Huelle
+ *     von `wache --hook`, die Claude Code parst. Ein deutscher Satz
+ *     mittendrin macht `JSON.parse` ueber die ganze Ausgabe unmoeglich -- und
+ *     genau das verbietet US-1 ("nie mittendrin") schon fuer den
+ *     Update-Hinweis in `endeMitHinweis`. Dann ist der Rueckgabewert die
+ *     ehrliche Auskunft; der Datenkanal ist keine Protokollzeile wert.
+ * Gemessen vor der Reparatur: `quatschbefehl` mit nur-lesbarem stderr legte
+ * `kimal3: Ausgabekanal-Fehler -- EBADF ...` auf stdout.
+ *
+ * 🔴 UND EIN EINMAL-RIEGEL, DAMIT DAS PROGRAMM UEBERHAUPT ENDET (Befund W-1b,
+ * dieselbe Durchsicht): Solange beide Empfaenger einander anschrieben, erzeugte
+ * jeder Schreibversuch das naechste `'error'`-Ereignis auf dem anderen Kanal --
+ * bei ZWEI kaputten Kanaelen (eine volle Platte genuegt:
+ * `kimal3 firma daten > a.json 2> b.txt` -> ENOSPC auf beiden) endete das
+ * Programm damit NIE. Gemessen: nach 8 Sekunden noch da, musste abgeschossen
+ * werden; dieselbe Lage ohne die Empfaenger endete in 36 ms. Und die
+ * 2-Sekunden-Notbremse half nicht: Sie wird erst IN `endeMitHinweis` gestellt
+ * und vom Ereignis-Pingpong ausgehungert. `schonGemeldet` schneidet das ab --
+ * eine Meldung pro Programmlauf, mehr braucht niemand.
+ *
+ * 🔑 KEIN `process.exit` HIER (Constraint 2): Nur `exitCode` wird gesetzt --
+ * das Programm endet von selbst, sobald kein Ereignis mehr nachkommt, und
+ * genau dafuer sorgt der Einmal-Riegel.
+ *
+ * Registriert wird das genau EINMAL pro Kanal, hier -- nicht an jeder
+ * einzelnen Schreibstelle. `console.log`/`console.error` UND die zwei
+ * direkten `process.stdout.write`/`process.stderr.write`-Aufrufe in
+ * `endeMitHinweis` schreiben alle auf DIESELBEN zwei Stream-Objekte
+ * (`process.stdout`, `process.stderr` sind pro Prozess EINMALIG vorhanden);
+ * ein Empfaenger auf dem Stream selbst deckt deshalb jede Schreibstelle im
+ * ganzen Programm ab, auch die in den einzelnen `befehle/*.ts`-Dateien.
+ */
+/**
+ * @param meldenAuf Wohin die Meldung darf -- oder `null` fuer "nirgends".
+ *   `null` steht fuer den Fehlerkanal selbst: Ist ER kaputt, bleibt nur der
+ *   Rueckgabewert, denn der Datenkanal gehoert der Maschinenform.
+ */
+function gegenUnbehandelteKanalfehlerAbsichern(kanal, meldenAuf) {
+    kanal.on("error", (fehler) => {
+        if (fehler.code === "EPIPE")
+            return;
+        /*
+          🔴 NUR SETZEN, WENN NOCH KEIN FEHLSCHLAG VERMERKT IST (Befund des
+          Koordinators, Fix-Runde 1). Ein Kanalfehler kann auftreten, WAEHREND
+          gerade eine viel genauere Fehlermeldung geschrieben wird -- der
+          `.catch`-Zweig am Dateiende setzt `process.exitCode = 2` ("bitte
+          einloggen") bzw. `3` ("nicht erreichbar") direkt NACH dem
+          `console.error`-Aufruf, der den Kanalfehler ueberhaupt erst ausloest.
+          Ein bedingungsloses `process.exitCode = 1` hier ueberschreibt diese
+          genauere Zahl mit der ungenaueren -- gemessen (Koordinator): Ausweis
+          fehlt, `projekt liste`, Fehlerkanal nur zum Lesen geoeffnet -> `2` geht
+          verloren, es bleibt nur `1`. Das ist derselbe Fehler wie bei
+          `bestaetigungenAktivieren` in der Projekt-CLAUDE.md: Ein Fehlerfall darf
+          nicht in einen anderen zusammenfallen, denn die Seite (hier: Claude)
+          kann nur unterscheiden, was der Rueckgabewert noch unterscheidet.
+    
+          Deshalb: Nur ein UNDEFINIERTER oder ein ERFOLGREICHER (`0`) Stand gilt
+          als "noch kein Fehlschlag vermerkt" -- ausdruecklich BEIDE pruefen,
+          nicht nur auf `0`, denn `process.exitCode` ist am Programmanfang
+          `undefined`, nicht `0`. Jede bereits gesetzte Zahl ungleich `0`
+          (`1`, `2`, `3`, `4`) ist die genauere Auskunft und bleibt stehen.
+        */
+        if (process.exitCode === undefined || process.exitCode === 0)
+            process.exitCode = 1;
+        if (meldenAuf === null || schonGemeldet)
+            return;
+        schonGemeldet = true;
+        try {
+            meldenAuf.write(`kimal3: Ausgabekanal-Fehler -- ${fehler.message}\n`);
+        }
+        catch {
+            // Auch der Fehlerkanal kann kaputt sein -- dann bleibt wenigstens der
+            // Rueckgabewert (oben gesetzt) die ehrliche Auskunft.
+        }
+    });
+}
+gegenUnbehandelteKanalfehlerAbsichern(process.stdout, process.stderr);
+gegenUnbehandelteKanalfehlerAbsichern(process.stderr, null);
 // 📌 Kein handgeschriebener Block mehr (2026-08-18): Die Liste wohnt in
 // `befehle-katalog.ts` und wird von dort AUCH im Pro-Bereich der App angezeigt.
 // Zwei Listen ueber dieselben Befehle driften — die eine bekaeme den naechsten

package/dist/zz-kaputt.js

@@ -0,0 +1 @@
+export const x = "das ist keine Zahl";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kimal3",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "description": "Trag deine KI-Projekte dort ein, wo sie entstehen: im Terminal.",
   "type": "module",
   "bin": {