blun-king-cli 9.1.19 → 9.1.21

package/bin/update-notice.js

@@ -23,6 +23,7 @@ const FALLBACK_MANIFEST_URL = 'https://chat.blun.ai/blun-code-version.json';
 const SNOOZE_MS = 7 * 24 * 60 * 60 * 1000;
 const REQUEST_TIMEOUT_MS = 2_500;
 const STATE_FILE = 'update-notice.json';
+const UPDATE_SKIP_FILE = 'update-skip-version.json';
 const UPDATE_DIRECTORY = 'updates';
 const UPDATE_KEY_ESCAPE_TIMEOUT_MS = 500;
 const UPDATE_SIGNAL_EXIT_CODES = Object.freeze({
@@ -382,6 +383,57 @@ function writeSnoozeState(blunDir, now = Date.now()) {
   }
 }
 
+function skippedVersionPath(blunDir) {
+  return path.join(blunDir, UPDATE_SKIP_FILE);
+}
+
+function readSkippedVersion(blunDir) {
+  try {
+    const filePath = skippedVersionPath(blunDir);
+    if (!fs.existsSync(filePath)) return undefined;
+    securePrivateFile(filePath);
+    const stat = fs.lstatSync(filePath);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 1_024) return undefined;
+    const record = exactDataRecord(JSON.parse(fs.readFileSync(filePath, 'utf8')), [
+      'skippedVersion',
+      'version',
+    ]);
+    if (!record || record.version !== 1 || !parseSemver(record.skippedVersion)) {
+      return undefined;
+    }
+    return record.skippedVersion;
+  } catch {
+    return undefined;
+  }
+}
+
+function writeSkippedVersion(blunDir, skippedVersion) {
+  if (!parseSemver(skippedVersion)) throw new Error('INVALID_UPDATE_VERSION');
+  ensurePrivateDirectory(blunDir);
+  const filePath = skippedVersionPath(blunDir);
+  const temporaryPath = path.join(
+    blunDir,
+    `.${UPDATE_SKIP_FILE}.${process.pid}.${randomUUID()}.tmp`,
+  );
+  try {
+    writePrivateFile(temporaryPath, `${JSON.stringify({
+      version: 1,
+      skippedVersion,
+    })}\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 }) {
   return Array.isArray(argv)
     && argv.length === 0
@@ -394,30 +446,68 @@ function installCommandText(version) {
   return `npm i -g ${PACKAGE_NAME}@${version}`;
 }
 
+function createUpdateProgress(output) {
+  const enabled = output?.isTTY === true;
+  const phaseCount = 4;
+  const width = 24;
+  const cyan = '\u001B[36m';
+  const dim = '\u001B[2m';
+  const reset = '\u001B[0m';
+  let active = false;
+  const update = (phase, label) => {
+    if (!enabled) return;
+    const completed = Math.max(0, Math.min(phaseCount, phase));
+    const filled = Math.round((completed / phaseCount) * width);
+    const bar = `${'━'.repeat(filled)}${'─'.repeat(width - filled)}`;
+    output.write(`\r\u001B[2K${cyan}${bar}${reset} ${dim}${completed}/${phaseCount}${reset} ${label}`);
+    active = completed < phaseCount;
+    if (!active) output.write('\n');
+  };
+  update.finish = () => {
+    if (!enabled || !active) return;
+    active = false;
+    output.write('\n');
+  };
+  return update;
+}
+
 function promptUpdateAction({ currentVersion, release, input, output, processRef = process }) {
   return new Promise((resolve, reject) => {
-    let selected = 1;
+    let selected = 0;
     let settled = false;
     let cursorHidden = false;
     let escapeTimer;
     let pendingInput = '';
     const decoder = new StringDecoder('utf8');
     const wasRaw = input.isRaw === true;
-    const actions = ['Herunterladen und installieren', 'Aussetzen'];
+    const cyan = '\u001B[36m';
+    const dim = '\u001B[2m';
+    const underline = '\u001B[4m';
+    const reset = '\u001B[0m';
+    const actions = [
+      {
+        choice: 'install',
+        label: `Jetzt aktualisieren (führt \`${installCommandText(release.version)}\` aus)`,
+      },
+      { choice: 'skip-once', label: 'Überspringen' },
+      { choice: 'skip-version', label: 'Auf den nächsten Release warten' },
+    ];
     const signalHandlers = new Map();
 
     const renderActions = (refresh) => {
-      if (refresh) output.write('\u001B[2F');
+      if (refresh) output.write(`\u001B[${actions.length + 1}F`);
       for (let index = 0; index < actions.length; index += 1) {
-        output.write(`\r\u001B[2K  ${selected === index ? '>' : ' '} ${actions[index]}\n`);
+        const line = `${selected === index ? '›' : ' '} ${index + 1}. ${actions[index].label}`;
+        output.write(`\r\u001B[2K${selected === index ? cyan : ''}${line}${selected === index ? reset : ''}\n`);
       }
+      output.write(`\r\u001B[2K${dim}Enter drücken, um fortzufahren${reset}\n`);
     };
     const cleanup = () => {
       if (escapeTimer !== undefined) clearTimeout(escapeTimer);
       input.removeListener('data', onData);
-      input.removeListener('end', postpone);
-      input.removeListener('close', postpone);
-      input.removeListener('error', postpone);
+      input.removeListener('end', skipOnce);
+      input.removeListener('close', skipOnce);
+      input.removeListener('error', skipOnce);
       for (const [signal, handler] of signalHandlers) {
         processRef.removeListener(signal, handler);
       }
@@ -464,14 +554,14 @@ function promptUpdateAction({ currentVersion, release, input, output, processRef
       if (typeof processRef.exit === 'function') processRef.exit(exitCode);
       reject(error);
     };
-    function postpone() {
-      finish('postpone');
+    function skipOnce() {
+      finish('skip-once');
     }
     const waitForEscapeSuffix = () => {
       if (escapeTimer !== undefined) return;
       escapeTimer = setTimeout(() => {
         escapeTimer = undefined;
-        postpone();
+        skipOnce();
       }, UPDATE_KEY_ESCAPE_TIMEOUT_MS);
     };
     const clearEscapeTimer = () => {
@@ -500,23 +590,30 @@ function promptUpdateAction({ currentVersion, release, input, output, processRef
       while (pendingInput.length > 0) {
         const first = pendingInput[0];
         if (first === '\u0003') {
-          postpone();
+          skipOnce();
           return;
         }
         if (first === '\r' || first === '\n') {
           pendingInput = pendingInput.slice(1);
-          finish(selected === 0 ? 'install' : 'postpone');
+          finish(actions[selected].choice);
           return;
         }
         if (first !== '\u001B') {
+          const numericSelection = Number(first) - 1;
           pendingInput = pendingInput.slice(1);
+          if (Number.isInteger(numericSelection)
+            && numericSelection >= 0
+            && numericSelection < actions.length) {
+            selected = numericSelection;
+            renderActions(true);
+          }
           continue;
         }
         if (pendingInput.length > 1
           && (pendingInput[1] === '\r'
             || pendingInput[1] === '\n'
             || pendingInput[1] === '\u0003')) {
-          postpone();
+          skipOnce();
           return;
         }
         const sequence = readEscapeSequence();
@@ -526,13 +623,13 @@ function promptUpdateAction({ currentVersion, release, input, output, processRef
         }
         clearEscapeTimer();
         if (sequence === '\u001B[A' || sequence === '\u001B[D') {
-          selected = 0;
+          selected = (selected - 1 + actions.length) % actions.length;
           pendingInput = pendingInput.slice(sequence.length);
           renderActions(true);
           continue;
         }
         if (sequence === '\u001B[B' || sequence === '\u001B[C') {
-          selected = 1;
+          selected = (selected + 1) % actions.length;
           pendingInput = pendingInput.slice(sequence.length);
           renderActions(true);
           continue;
@@ -558,16 +655,18 @@ function promptUpdateAction({ currentVersion, release, input, output, processRef
         signalHandlers.set(signal, handler);
         processRef.once(signal, handler);
       }
-      output.write(`\nNeues Update verfügbar (${currentVersion} -> ${release.version})\n`);
-      if (release.notesUrl) output.write(`Versionshinweise: ${release.notesUrl}\n`);
-      output.write(`Installationsbefehl: ${installCommandText(release.version)}\n\n`);
+      output.write(`\nBLUN Code-Update verfügbar: ${currentVersion} -> ${release.version}\n`);
+      if (release.notesUrl) {
+        output.write(`${dim}Versionshinweise:${reset} ${underline}${release.notesUrl}${reset}\n`);
+      }
+      output.write('\n');
       cursorHidden = true;
       output.write('\u001B[?25l');
       renderActions(false);
       input.on('data', onData);
-      input.once('end', postpone);
-      input.once('close', postpone);
-      input.once('error', postpone);
+      input.once('end', skipOnce);
+      input.once('close', skipOnce);
+      input.once('error', skipOnce);
       if (typeof input.setRawMode === 'function') input.setRawMode(true);
       if (typeof input.resume === 'function') input.resume();
     } catch (error) {
@@ -1121,6 +1220,9 @@ async function runUpdateFlow(options, explicitUpdate) {
         ? explicitNoTarget(stdout, reason)
         : { kind: 'continue', reason };
     }
+    if (!explicitUpdate && readSkippedVersion(blunDir) === release.version) {
+      return { kind: 'continue', reason: 'skipped_version' };
+    }
     if (explicitUpdate) {
       try {
         ensurePrivateDirectory(blunDir);
@@ -1177,6 +1279,17 @@ async function runUpdateFlow(options, explicitUpdate) {
     }
     if (action !== 'install') {
       if (installerSession?.ready) await installerSession.cancel();
+      if (action === 'skip-once') {
+        return { kind: 'continue', reason: 'skipped_once' };
+      }
+      if (action === 'skip-version') {
+        try {
+          writeSkippedVersion(blunDir, release.version);
+        } catch {
+          // A failed preference write must not block the existing console.
+        }
+        return { kind: 'continue', reason: 'skipped_version' };
+      }
       try {
         writeSnoozeState(blunDir, (options.now || Date.now)());
       } catch {
@@ -1185,6 +1298,10 @@ async function runUpdateFlow(options, explicitUpdate) {
       return { kind: 'continue', reason: 'postponed' };
     }
 
+    const updateProgress = createUpdateProgress(stdout);
+    updateProgress(1, 'Update geprüft');
+    updateProgress(2, 'Installer bereit');
+
     try {
       lease.assertOwned();
     } catch {
@@ -1193,6 +1310,7 @@ async function runUpdateFlow(options, explicitUpdate) {
         : { kind: 'update_in_progress' };
     }
     let installResult;
+    updateProgress(3, 'Paket wird installiert');
     try {
       installResult = options.installVersion
         ? await options.installVersion(release.version)
@@ -1203,22 +1321,26 @@ async function runUpdateFlow(options, explicitUpdate) {
     if (installResult?.leaseBusy === true
       || installResult?.leaseUnavailable === true
       || installResult?.unknownState === true) {
+      updateProgress.finish();
       return explicitUpdate
         ? explicitFailure(stderr, 'update_in_progress')
         : { kind: 'update_in_progress' };
     }
     if (installResult?.code === 0 && installResult?.verified === true) {
+      updateProgress(4, 'Installation geprüft');
       stdout.write('Update erfolgreich installiert. Starte BLUN Code neu, um die neue Version zu verwenden.\n');
       return { kind: 'installed', version: release.version };
     }
 
     if (Number.isInteger(installResult?.code) && installResult.code !== 0) {
+      updateProgress.finish();
       if (explicitUpdate) {
         return explicitFailure(stderr, 'install_failed', installResult.code);
       }
       stderr.write(`Update fehlgeschlagen (Code ${installResult.code}). Die vorhandene Version wird gestartet.\n`);
       return { kind: 'continue', reason: 'install_failed', exitCode: installResult.code };
     }
+    updateProgress.finish();
     if (explicitUpdate) return explicitFailure(stderr, 'verification_failed');
     stderr.write('Update konnte nicht verifiziert werden. Starte BLUN Code neu.\n');
     return { kind: 'update_in_progress' };
@@ -1258,10 +1380,12 @@ module.exports = {
   parseFallbackManifest,
   parseRegistryDocument,
   promptUpdateAction,
+  readSkippedVersion,
   readSnoozeState,
   requestTrustedJson,
   resolveEffectiveRelease,
   runExplicitUpdate,
   runUpdateNotice,
+  writeSkippedVersion,
   writeSnoozeState,
 };