blun-king-cli 9.1.41 → 9.1.43

package/LIESMICH.txt

@@ -9,7 +9,7 @@ Installation
 ------------
 Die geprüfte Version exakt global installieren:
 
-  npm install -g blun-king-cli@9.1.36
+  npm install -g blun-king-cli@9.1.43
 
 Start
 -----
@@ -20,6 +20,17 @@ Start
 Beide Startbefehle verwenden dieselbe Version, dasselbe Konto, dasselbe Modell
 und dieselben Befehle.
 
+Zug-Wächter
+-----------
+Läuft ein Zug 20 Minuten ohne neues Werkzeugergebnis, meldet die Konsole den
+Stand auch im verbundenen Telegram-Kanal. Fünf aufeinanderfolgende identische
+fehlgeschlagene Werkzeugaufrufe beenden den Zug mit einer Fehlermeldung.
+
+Die Grenzwerte lassen sich vor dem Start über diese Umgebungsvariablen ändern:
+
+  BLUN_TURN_WATCHDOG_IDLE_MINUTES
+  BLUN_TURN_WATCHDOG_MAX_FAILED_REPETITIONS
+
 Nachweisbare Arbeitsabläufe
 ---------------------------
 

package/README.md

@@ -9,7 +9,7 @@ Voraussetzung ist Node.js 24.15 oder neuer. Die geprüfte Version wird exakt
 installiert:
 
 ```powershell
-npm install -g blun-king-cli@9.1.36
+npm install -g blun-king-cli@9.1.43
 ```
 
 ## Reproduzierbares Staging und Packen
@@ -35,6 +35,16 @@ an. Version, Konto, Modell und Befehle sind ansonsten identisch. Der Unterschied
 gilt nur für den laufenden Prozess; die gespeicherte
 Plugin-Konfiguration wird nicht umgeschrieben.
 
+## Zug-Wächter
+
+Läuft ein Zug 20 Minuten ohne neues Werkzeugergebnis, meldet die Konsole den
+Stand auch im verbundenen Telegram-Kanal. Fünf aufeinanderfolgende identische
+fehlgeschlagene Werkzeugaufrufe beenden den Zug mit einer Fehlermeldung.
+
+Die Grenzwerte lassen sich vor dem Start mit
+`BLUN_TURN_WATCHDOG_IDLE_MINUTES` und
+`BLUN_TURN_WATCHDOG_MAX_FAILED_REPETITIONS` ändern.
+
 Beim ersten Start werden das Telegram-Plugin und die mitgelieferten Skills
 eingerichtet. Die Anmeldung erfolgt anschließend in der
 Konsole mit `/login` über den BLUN-OAuth-Server. Das Paket erzeugt keine

package/bin/update-notice.js

@@ -26,6 +26,7 @@ const STATE_FILE = 'update-notice.json';
 const UPDATE_SKIP_FILE = 'update-skip-version.json';
 const PENDING_UPDATE_FILE = 'update-pending.json';
 const UPDATE_DIRECTORY = 'updates';
+const CORE_INSTALL_STATE_FILE = 'install.json';
 const UPDATE_KEY_ESCAPE_TIMEOUT_MS = 500;
 const UPDATE_SIGNAL_EXIT_CODES = Object.freeze({
   SIGHUP: 129,
@@ -45,14 +46,25 @@ const SEMVER_PATTERN = new RegExp(
     + `(?:-(${SEMVER_IDENTIFIER}(?:\\.${SEMVER_IDENTIFIER})*))?`
     + '(?:\\+([0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?$',
 );
+const LEGACY_MANIFEST_KEYS = Object.freeze([
+  'install',
+  'latest',
+  'minSupported',
+  'name',
+  'notesUrl',
+  'releasedAt',
+]);
 const MANIFEST_KEYS = Object.freeze([
   'install',
   'latest',
   'minSupported',
   'name',
   'notesUrl',
+  'releaseNotes',
   'releasedAt',
 ]);
+const RELEASE_NOTES_MAX_COUNT = 8;
+const RELEASE_NOTE_MAX_BYTES = 240;
 const ENDPOINT_LIMITS = new Map([
   [REGISTRY_URL, 1024 * 1024],
   [FALLBACK_MANIFEST_URL, 64 * 1024],
@@ -192,9 +204,23 @@ function isIsoTimestamp(value) {
     && date.getUTCSeconds() === Number(match[6]);
 }
 
+function parseReleaseNotes(value) {
+  if (!Array.isArray(value) || value.length > RELEASE_NOTES_MAX_COUNT) return undefined;
+  const notes = [];
+  for (const note of value) {
+    if (!isBoundedText(note, RELEASE_NOTE_MAX_BYTES)) return undefined;
+    notes.push(note);
+  }
+  return Object.freeze(notes);
+}
+
 function parseFallbackManifest(value) {
-  const record = exactDataRecord(value, MANIFEST_KEYS);
+  const record = exactDataRecord(value, MANIFEST_KEYS)
+    || exactDataRecord(value, LEGACY_MANIFEST_KEYS);
   const notesUrl = record ? canonicalOfficialNotesUrl(record.notesUrl) : undefined;
+  const releaseNotes = record && Object.hasOwn(record, 'releaseNotes')
+    ? parseReleaseNotes(record.releaseNotes)
+    : undefined;
   if (!record
     || record.name !== PACKAGE_NAME
     || !parseSemver(record.latest)
@@ -202,6 +228,7 @@ function parseFallbackManifest(value) {
     || compareSemver(record.minSupported, record.latest) === 1
     || !isIsoTimestamp(record.releasedAt)
     || !notesUrl
+    || (Object.hasOwn(record, 'releaseNotes') && releaseNotes === undefined)
     || !isBoundedText(record.install, 256)) {
     return undefined;
   }
@@ -211,6 +238,7 @@ function parseFallbackManifest(value) {
     minSupported: record.minSupported,
     releasedAt: record.releasedAt,
     notesUrl,
+    ...(releaseNotes === undefined ? {} : { releaseNotes }),
     install: record.install,
   });
 }
@@ -243,7 +271,14 @@ function resolveEffectiveRelease(currentVersion, registryTags, fallbackManifest)
   if (compareSemver(version, currentVersion) <= 0) return undefined;
 
   if (validFallback && compareSemver(validFallback.latest, version) === 0) {
-    return { channel: 'stable', version, notesUrl: validFallback.notesUrl };
+    return {
+      channel: 'stable',
+      version,
+      notesUrl: validFallback.notesUrl,
+      ...(validFallback.releaseNotes === undefined
+        ? {}
+        : { releaseNotes: validFallback.releaseNotes }),
+    };
   }
   return { channel: 'stable', version };
 }
@@ -495,6 +530,50 @@ function clearPendingUpdate(blunDir) {
   fs.rmSync(pendingUpdatePath(blunDir), { force: true });
 }
 
+function writeCoreInstallSuccess(
+  blunDir,
+  fromVersion,
+  version,
+  releaseNotes,
+  now = Date.now(),
+) {
+  if (!parseSemver(fromVersion) || !parseSemver(version)) {
+    throw new Error('INVALID_UPDATE_VERSION');
+  }
+  const updateDirectory = path.join(blunDir, UPDATE_DIRECTORY);
+  ensurePrivateDirectory(blunDir);
+  ensurePrivateDirectory(updateDirectory);
+  const filePath = path.join(updateDirectory, CORE_INSTALL_STATE_FILE);
+  const temporaryPath = path.join(
+    updateDirectory,
+    `.${CORE_INSTALL_STATE_FILE}.${process.pid}.${randomUUID()}.tmp`,
+  );
+  try {
+    writePrivateFile(temporaryPath, `${JSON.stringify({
+      active: null,
+      lastFailure: null,
+      lastSuccess: {
+        version,
+        fromVersion,
+        ...(releaseNotes === undefined ? {} : { releaseNotes }),
+        installedAt: new Date(now).toISOString(),
+        notifiedAt: null,
+      },
+    })}\n`);
+    const handle = fs.openSync(temporaryPath, 'r+');
+    try {
+      fs.fsyncSync(handle);
+    } finally {
+      fs.closeSync(handle);
+    }
+    fs.renameSync(temporaryPath, filePath);
+    securePrivateFile(filePath);
+  } catch (error) {
+    fs.rmSync(temporaryPath, { force: true });
+    throw error;
+  }
+}
+
 function isInteractiveUpdateStart({ argv, env, stdin, stdout }) {
   const isOrdinaryStartup = Array.isArray(argv)
     && (argv.length === 0
@@ -1178,10 +1257,10 @@ function noReleaseReason(currentVersion, registryTags, fallbackManifest) {
   return parseSemver(latest) || fallbackManifest ? 'current' : 'unavailable';
 }
 
-function explicitNoTarget(stdout, reason) {
+function explicitNoTarget(stdout, reason, currentVersion) {
   stdout.write(reason === 'current'
-    ? 'Kein Update verfügbar. BLUN Code ist auf dem aktuellen Updatekanal.\n'
-    : 'Kein sicherer Update-Zielstand verfügbar.\n');
+    ? `Kein Update verfügbar. Installiert: ${currentVersion} · Aktuell: ${currentVersion}.\n`
+    : `Kein sicherer Update-Zielstand verfügbar. Installiert: ${currentVersion}.\n`);
   return { kind: 'current', reason };
 }
 
@@ -1280,7 +1359,7 @@ async function runUpdateFlow(options, explicitUpdate) {
       sources = await (options.loadReleaseSources || loadReleaseSources)();
     } catch {
       return explicitUpdate
-        ? explicitNoTarget(stdout, 'unavailable')
+        ? explicitNoTarget(stdout, 'unavailable', currentVersion)
         : { kind: 'continue', reason: 'unavailable' };
     }
     const registryTags = parseRegistryDocument(sources?.registryDocument);
@@ -1289,7 +1368,7 @@ async function runUpdateFlow(options, explicitUpdate) {
     if (!release) {
       const reason = noReleaseReason(currentVersion, registryTags, fallbackManifest);
       return explicitUpdate
-        ? explicitNoTarget(stdout, reason)
+        ? explicitNoTarget(stdout, reason, currentVersion)
         : { kind: 'continue', reason };
     }
     const queuedForRelease = pendingVersion === release.version;
@@ -1413,7 +1492,23 @@ async function runUpdateFlow(options, explicitUpdate) {
     if (installResult?.code === 0 && installResult?.verified === true) {
       updateProgress(4, 'Installation geprüft');
       clearPendingUpdate(blunDir);
-      stdout.write('Update erfolgreich installiert. Starte BLUN Code neu, um die neue Version zu verwenden.\n');
+      try {
+        writeCoreInstallSuccess(
+          blunDir,
+          currentVersion,
+          release.version,
+          release.releaseNotes,
+          (options.now || Date.now)(),
+        );
+      } catch {
+        stderr.write(
+          `Update ${release.version} wurde installiert, aber die Startmeldung konnte nicht gespeichert werden.\n`,
+        );
+      }
+      stdout.write(
+        `Update ${currentVersion} -> ${release.version} erfolgreich installiert. Starte BLUN Code neu, um die neue Version zu verwenden.\n`,
+      );
+      if (release.notesUrl) stdout.write(`Versionshinweise: ${release.notesUrl}\n`);
       return { kind: 'installed', version: release.version };
     }