blun-king-cli 9.0.1 → 9.1.0

package/bin/update-notice.js

@@ -3,7 +3,6 @@
 const { randomUUID } = require('node:crypto');
 const fs = require('node:fs');
 const https = require('node:https');
-const os = require('node:os');
 const path = require('node:path');
 const { fork } = require('node:child_process');
 const { StringDecoder } = require('node:string_decoder');
@@ -24,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_DIRECTORY = 'updates';
 const UPDATE_KEY_ESCAPE_TIMEOUT_MS = 500;
 const UPDATE_SIGNAL_EXIT_CODES = Object.freeze({
   SIGHUP: 129,
@@ -135,7 +135,10 @@ function parseRegistryDocument(value) {
   const tags = readDataProperty(value, 'dist-tags');
   const latest = readDataProperty(tags, 'latest');
   if (!parseSemver(latest)) return undefined;
-  return latest;
+  const parsed = { latest };
+  const next = readDataProperty(tags, 'next');
+  if (parseSemver(next)) parsed.next = next;
+  return Object.freeze(parsed);
 }
 
 function isBoundedText(value, maxBytes) {
@@ -203,24 +206,37 @@ function parseFallbackManifest(value) {
   });
 }
 
-function resolveEffectiveRelease(registryVersion, fallbackManifest) {
-  const validRegistryVersion = parseSemver(registryVersion) ? registryVersion : undefined;
+function resolveEffectiveRelease(currentVersion, registryTags, fallbackManifest) {
+  if (!parseSemver(currentVersion)) return undefined;
+  const registryLatest = readDataProperty(registryTags, 'latest');
+  const validRegistryLatest = parseSemver(registryLatest) ? registryLatest : undefined;
+  const registryNext = readDataProperty(registryTags, 'next');
+  const validRegistryNext = parseSemver(registryNext) ? registryNext : undefined;
   const validFallback = parseFallbackManifest(fallbackManifest);
-  if (!validRegistryVersion && !validFallback) return undefined;
+  if (!validRegistryLatest && !validFallback) return undefined;
+
+  if (validRegistryLatest && compareSemver(currentVersion, validRegistryLatest) > 0) {
+    if (!validRegistryNext || compareSemver(validRegistryNext, currentVersion) <= 0) {
+      return undefined;
+    }
+    return { channel: 'next', version: validRegistryNext };
+  }
 
   let version;
-  if (validRegistryVersion && validFallback) {
-    version = compareSemver(validRegistryVersion, validFallback.latest) <= 0
-      ? validRegistryVersion
+  if (validRegistryLatest && validFallback) {
+    version = compareSemver(validRegistryLatest, validFallback.latest) <= 0
+      ? validRegistryLatest
       : validFallback.latest;
   } else {
-    version = validRegistryVersion || validFallback.latest;
+    version = validRegistryLatest || validFallback.latest;
   }
 
+  if (compareSemver(version, currentVersion) <= 0) return undefined;
+
   if (validFallback && compareSemver(validFallback.latest, version) === 0) {
-    return { version, notesUrl: validFallback.notesUrl };
+    return { channel: 'stable', version, notesUrl: validFallback.notesUrl };
   }
-  return { version };
+  return { channel: 'stable', version };
 }
 
 function requestTrustedJson(url, options = {}) {
@@ -319,6 +335,8 @@ function statePath(blunDir) {
 function readSnoozeState(blunDir, now = Date.now()) {
   try {
     const filePath = statePath(blunDir);
+    if (!fs.existsSync(filePath)) return false;
+    securePrivateFile(filePath);
     const stat = fs.lstatSync(filePath);
     if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 1_024) return false;
     const record = exactDataRecord(JSON.parse(fs.readFileSync(filePath, 'utf8')), [
@@ -672,10 +690,50 @@ function createInstallEnvironment(sourceEnv, installDirectory, npmConfigPath) {
   return result;
 }
 
-function createPrivateInstallDirectory(tempRoot = os.tmpdir()) {
-  const directory = fs.mkdtempSync(path.join(path.resolve(tempRoot), 'blun-update-'));
-  ensurePrivateDirectory(directory);
-  return directory;
+function pathIsWithin(root, candidate) {
+  const relative = path.relative(root, candidate);
+  return relative === '' || (!relative.startsWith(`..${path.sep}`)
+    && relative !== '..'
+    && !path.isAbsolute(relative));
+}
+
+function resolveInstallTempRoot(options) {
+  if (typeof options.blunDir !== 'string' || options.blunDir.trim().length === 0) {
+    throw new Error('INVALID_UPDATE_BLUN_HOME');
+  }
+  const updateRoot = path.join(path.resolve(options.blunDir), UPDATE_DIRECTORY);
+  if (options.tempRoot === undefined) return updateRoot;
+  const explicitRoot = path.resolve(options.tempRoot);
+  if (!pathIsWithin(updateRoot, explicitRoot)) {
+    throw new Error('INVALID_UPDATE_TEMP_ROOT');
+  }
+  return explicitRoot;
+}
+
+function createPrivateInstallDirectory(tempRoot, blunDir) {
+  const updateRoot = path.join(path.resolve(blunDir), UPDATE_DIRECTORY);
+  let current = updateRoot;
+  ensurePrivateDirectory(current);
+  const relative = path.relative(updateRoot, tempRoot);
+  if (relative !== '') {
+    for (const segment of relative.split(path.sep)) {
+      current = path.join(current, segment);
+      ensurePrivateDirectory(current);
+    }
+  }
+  let directory;
+  try {
+    directory = fs.mkdtempSync(path.join(tempRoot, 'blun-update-'));
+    ensurePrivateDirectory(directory);
+    return directory;
+  } catch (error) {
+    if (directory) {
+      try {
+        fs.rmSync(directory, { recursive: true, force: true });
+      } catch {}
+    }
+    throw error;
+  }
 }
 
 function verifyInstalledPackageVersion(packageRoot, version) {
@@ -764,7 +822,6 @@ function preparePinnedInstaller(version, options = {}) {
         finishDisconnected,
         options.disconnectTimeoutMs || 1_000,
       );
-      disconnectTimer.unref?.();
     };
     const sendControl = (type) => {
       if (selectedAction) return closePromise;
@@ -787,7 +844,10 @@ function preparePinnedInstaller(version, options = {}) {
     };
     let prepareTimeout;
     try {
-      installDirectory = createPrivateInstallDirectory(options.tempRoot);
+      installDirectory = createPrivateInstallDirectory(
+        resolveInstallTempRoot(options),
+        options.blunDir,
+      );
       npmConfigPath = path.join(installDirectory, 'npmrc');
       writePrivateFile(npmConfigPath, '');
       invocation = createInstallInvocation(version, { ...options, npmConfigPath });
@@ -923,7 +983,39 @@ async function probeInstallLease(options, packageRoot) {
   return 'clear';
 }
 
-async function runUpdateNotice(options) {
+function noReleaseReason(currentVersion, registryTags, fallbackManifest) {
+  const latest = readDataProperty(registryTags, 'latest');
+  if (parseSemver(latest) && compareSemver(currentVersion, latest) > 0) {
+    const next = readDataProperty(registryTags, 'next');
+    return parseSemver(next) && compareSemver(next, currentVersion) === 0
+      ? 'current'
+      : 'unavailable';
+  }
+  return parseSemver(latest) || fallbackManifest ? 'current' : 'unavailable';
+}
+
+function explicitNoTarget(stdout, reason) {
+  stdout.write(reason === 'current'
+    ? 'Kein Update verfügbar. BLUN Code ist auf dem aktuellen Updatekanal.\n'
+    : 'Kein sicherer Update-Zielstand verfügbar.\n');
+  return { kind: 'current', reason };
+}
+
+function explicitFailure(stderr, reason, exitCode) {
+  const hasExitCode = Number.isInteger(exitCode) && exitCode !== 0;
+  if (hasExitCode) {
+    stderr.write(`Update fehlgeschlagen (Code ${exitCode}).\n`);
+  } else {
+    stderr.write('Das Update konnte nicht verifiziert werden.\n');
+  }
+  return {
+    kind: 'failed',
+    reason,
+    exitCode: hasExitCode ? exitCode : 1,
+  };
+}
+
+async function runUpdateFlow(options, explicitUpdate) {
   const {
     currentVersion,
     argv,
@@ -933,15 +1025,17 @@ async function runUpdateNotice(options) {
     stderr,
     blunDir,
   } = options;
-  if (!isInteractiveUpdateStart({ argv, env, stdin, stdout })) {
+  if (!explicitUpdate && !isInteractiveUpdateStart({ argv, env, stdin, stdout })) {
     return { kind: 'continue', reason: 'not_interactive' };
   }
   if (!parseSemver(currentVersion)) {
-    return { kind: 'continue', reason: 'invalid_current_version' };
+    return explicitUpdate
+      ? explicitFailure(stderr, 'invalid_current_version')
+      : { kind: 'continue', reason: 'invalid_current_version' };
   }
 
   const now = (options.now || Date.now)();
-  if (readSnoozeState(blunDir, now)) {
+  if (!explicitUpdate && readSnoozeState(blunDir, now)) {
     return { kind: 'continue', reason: 'snoozed' };
   }
 
@@ -952,12 +1046,20 @@ async function runUpdateNotice(options) {
     try {
       leaseResult = await (options.acquireLease || tryAcquireUpdateLease)({ packageRoot });
     } catch {
-      return { kind: 'continue', reason: 'lease_unavailable' };
+      return explicitUpdate
+        ? explicitFailure(stderr, 'lease_unavailable')
+        : { kind: 'continue', reason: 'lease_unavailable' };
     }
   } else {
     leaseResult = { acquired: true, lease: options.noticeLease };
   }
   if (!leaseResult?.acquired) {
+    if (explicitUpdate) {
+      return explicitFailure(
+        stderr,
+        leaseResult?.reason === 'busy' ? 'update_in_progress' : 'lease_unavailable',
+      );
+    }
     return leaseResult?.reason === 'busy'
       ? { kind: 'update_in_progress' }
       : { kind: 'continue', reason: 'lease_unavailable' };
@@ -966,58 +1068,90 @@ async function runUpdateNotice(options) {
   let installerSession;
 
   try {
-    if (readSnoozeState(blunDir, (options.now || Date.now)())) {
+    if (!explicitUpdate && readSnoozeState(blunDir, (options.now || Date.now)())) {
       return { kind: 'continue', reason: 'snoozed' };
     }
     const initialInstallLease = await probeInstallLease(options, packageRoot);
-    if (initialInstallLease === 'busy') return { kind: 'update_in_progress' };
+    if (initialInstallLease === 'busy') {
+      return explicitUpdate
+        ? explicitFailure(stderr, 'update_in_progress')
+        : { kind: 'update_in_progress' };
+    }
     if (initialInstallLease !== 'clear') {
-      return { kind: 'continue', reason: 'lease_unavailable' };
+      return explicitUpdate
+        ? explicitFailure(stderr, 'lease_unavailable')
+        : { kind: 'continue', reason: 'lease_unavailable' };
     }
     let sources;
     try {
       sources = await (options.loadReleaseSources || loadReleaseSources)();
     } catch {
-      return { kind: 'continue', reason: 'unavailable' };
+      return explicitUpdate
+        ? explicitNoTarget(stdout, 'unavailable')
+        : { kind: 'continue', reason: 'unavailable' };
     }
-    const registryVersion = parseRegistryDocument(sources?.registryDocument);
+    const registryTags = parseRegistryDocument(sources?.registryDocument);
     const fallbackManifest = parseFallbackManifest(sources?.fallbackDocument);
-    const release = resolveEffectiveRelease(registryVersion, fallbackManifest);
-    if (!release) return { kind: 'continue', reason: 'unavailable' };
-    if (compareSemver(release.version, currentVersion) <= 0) {
-      return { kind: 'continue', reason: 'current' };
+    const release = resolveEffectiveRelease(currentVersion, registryTags, fallbackManifest);
+    if (!release) {
+      const reason = noReleaseReason(currentVersion, registryTags, fallbackManifest);
+      return explicitUpdate
+        ? explicitNoTarget(stdout, reason)
+        : { kind: 'continue', reason };
+    }
+    if (explicitUpdate) {
+      try {
+        ensurePrivateDirectory(blunDir);
+      } catch {
+        return explicitFailure(stderr, 'private_home_unavailable');
+      }
     }
     try {
       lease.assertOwned();
     } catch {
-      return { kind: 'update_in_progress' };
+      return explicitUpdate
+        ? explicitFailure(stderr, 'update_in_progress')
+        : { kind: 'update_in_progress' };
     }
     const prePromptInstallLease = await probeInstallLease(options, packageRoot);
-    if (prePromptInstallLease === 'busy') return { kind: 'update_in_progress' };
+    if (prePromptInstallLease === 'busy') {
+      return explicitUpdate
+        ? explicitFailure(stderr, 'update_in_progress')
+        : { kind: 'update_in_progress' };
+    }
     if (prePromptInstallLease !== 'clear') {
-      return { kind: 'continue', reason: 'lease_unavailable' };
+      return explicitUpdate
+        ? explicitFailure(stderr, 'lease_unavailable')
+        : { kind: 'continue', reason: 'lease_unavailable' };
     }
     if (!options.installVersion) {
       installerSession = await (options.prepareInstaller || preparePinnedInstaller)(
         release.version,
-        { packageRoot },
+        { blunDir, packageRoot },
       );
       if (!installerSession?.ready) {
+        if (explicitUpdate) {
+          return explicitFailure(stderr, 'installer_unavailable');
+        }
         return installerSession?.reason === 'failed'
           ? { kind: 'continue', reason: 'installer_unavailable' }
           : { kind: 'update_in_progress' };
       }
     }
     let action;
-    try {
-      action = await (options.promptAction || promptUpdateAction)({
-        currentVersion,
-        release,
-        input: stdin,
-        output: stdout,
-      });
-    } catch {
-      return { kind: 'continue', reason: 'prompt_failed' };
+    if (explicitUpdate) {
+      action = 'install';
+    } else {
+      try {
+        action = await (options.promptAction || promptUpdateAction)({
+          currentVersion,
+          release,
+          input: stdin,
+          output: stdout,
+        });
+      } catch {
+        return { kind: 'continue', reason: 'prompt_failed' };
+      }
     }
     if (action !== 'install') {
       if (installerSession?.ready) await installerSession.cancel();
@@ -1032,7 +1166,9 @@ async function runUpdateNotice(options) {
     try {
       lease.assertOwned();
     } catch {
-      return { kind: 'update_in_progress' };
+      return explicitUpdate
+        ? explicitFailure(stderr, 'update_in_progress')
+        : { kind: 'update_in_progress' };
     }
     let installResult;
     try {
@@ -1045,7 +1181,9 @@ async function runUpdateNotice(options) {
     if (installResult?.leaseBusy === true
       || installResult?.leaseUnavailable === true
       || installResult?.unknownState === true) {
-      return { kind: 'update_in_progress' };
+      return explicitUpdate
+        ? explicitFailure(stderr, 'update_in_progress')
+        : { kind: 'update_in_progress' };
     }
     if (installResult?.code === 0 && installResult?.verified === true) {
       stdout.write('Update erfolgreich installiert. Starte BLUN Code neu, um die neue Version zu verwenden.\n');
@@ -1053,9 +1191,13 @@ async function runUpdateNotice(options) {
     }
 
     if (Number.isInteger(installResult?.code) && installResult.code !== 0) {
+      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 };
     }
+    if (explicitUpdate) return explicitFailure(stderr, 'verification_failed');
     stderr.write('Update konnte nicht verifiziert werden. Starte BLUN Code neu.\n');
     return { kind: 'update_in_progress' };
   } finally {
@@ -1072,6 +1214,14 @@ async function runUpdateNotice(options) {
   }
 }
 
+function runExplicitUpdate(options) {
+  return runUpdateFlow(options, true);
+}
+
+function runUpdateNotice(options) {
+  return runUpdateFlow(options, false);
+}
+
 module.exports = {
   FALLBACK_MANIFEST_URL,
   PACKAGE_NAME,
@@ -1089,6 +1239,7 @@ module.exports = {
   readSnoozeState,
   requestTrustedJson,
   resolveEffectiveRelease,
+  runExplicitUpdate,
   runUpdateNotice,
   writeSnoozeState,
 };