blun-king-cli 9.0.0 → 9.1.0

package/bin/update-notice.js

@@ -0,0 +1,1245 @@
+'use strict';
+
+const { randomUUID } = require('node:crypto');
+const fs = require('node:fs');
+const https = require('node:https');
+const path = require('node:path');
+const { fork } = require('node:child_process');
+const { StringDecoder } = require('node:string_decoder');
+const { types } = require('node:util');
+
+const { tryAcquireUpdateLease } = require('./update-lease');
+
+const {
+  ensurePrivateDirectory,
+  securePrivateFile,
+  writePrivateFile,
+} = require('./private-paths');
+
+const PACKAGE_NAME = 'blun-king-cli';
+const REGISTRY_URL = 'https://registry.npmjs.org/blun-king-cli';
+const INSTALL_REGISTRY_URL = 'https://registry.npmjs.org/';
+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,
+  SIGINT: 130,
+  SIGTERM: 143,
+});
+const SEMVER_IDENTIFIER = '(?:0|[1-9]\\d*|\\d*[A-Za-z-][0-9A-Za-z-]*)';
+const SEMVER_PATTERN = new RegExp(
+  `^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)`
+    + `(?:-(${SEMVER_IDENTIFIER}(?:\\.${SEMVER_IDENTIFIER})*))?`
+    + '(?:\\+([0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?$',
+);
+const MANIFEST_KEYS = Object.freeze([
+  'install',
+  'latest',
+  'minSupported',
+  'name',
+  'notesUrl',
+  'releasedAt',
+]);
+const ENDPOINT_LIMITS = new Map([
+  [REGISTRY_URL, 1024 * 1024],
+  [FALLBACK_MANIFEST_URL, 64 * 1024],
+]);
+
+function parseSemver(value) {
+  if (typeof value !== 'string' || value.length > 128) return undefined;
+  const match = SEMVER_PATTERN.exec(value);
+  if (!match) return undefined;
+  return {
+    raw: value,
+    core: [match[1], match[2], match[3]],
+    prerelease: match[4] === undefined ? undefined : match[4].split('.'),
+  };
+}
+
+function compareNumericIdentifier(left, right) {
+  if (left.length !== right.length) return left.length < right.length ? -1 : 1;
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+function comparePrerelease(left, right) {
+  if (left === undefined && right === undefined) return 0;
+  if (left === undefined) return 1;
+  if (right === undefined) return -1;
+  const length = Math.max(left.length, right.length);
+  for (let index = 0; index < length; index += 1) {
+    if (left[index] === undefined) return -1;
+    if (right[index] === undefined) return 1;
+    const leftNumeric = /^\d+$/.test(left[index]);
+    const rightNumeric = /^\d+$/.test(right[index]);
+    if (leftNumeric && rightNumeric) {
+      const comparison = compareNumericIdentifier(left[index], right[index]);
+      if (comparison !== 0) return comparison;
+    } else if (leftNumeric !== rightNumeric) {
+      return leftNumeric ? -1 : 1;
+    } else if (left[index] !== right[index]) {
+      return left[index] < right[index] ? -1 : 1;
+    }
+  }
+  return 0;
+}
+
+function compareSemver(leftValue, rightValue) {
+  const left = parseSemver(leftValue);
+  const right = parseSemver(rightValue);
+  if (!left || !right) return undefined;
+  for (let index = 0; index < left.core.length; index += 1) {
+    const comparison = compareNumericIdentifier(left.core[index], right.core[index]);
+    if (comparison !== 0) return comparison;
+  }
+  return comparePrerelease(left.prerelease, right.prerelease);
+}
+
+function exactDataRecord(value, expectedKeys) {
+  if (typeof value !== 'object' || value === null || Array.isArray(value) || types.isProxy(value)) {
+    return undefined;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) return undefined;
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  const keys = Object.keys(descriptors).toSorted();
+  if (keys.length !== expectedKeys.length
+    || keys.some((key, index) => key !== expectedKeys[index])) {
+    return undefined;
+  }
+  for (const key of keys) {
+    if (!Object.hasOwn(descriptors[key], 'value') || descriptors[key].enumerable !== true) {
+      return undefined;
+    }
+  }
+  return Object.fromEntries(keys.map((key) => [key, descriptors[key].value]));
+}
+
+function readDataProperty(value, key) {
+  if (typeof value !== 'object' || value === null || Array.isArray(value) || types.isProxy(value)) {
+    return undefined;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) return undefined;
+  const descriptor = Object.getOwnPropertyDescriptor(value, key);
+  if (!descriptor || !Object.hasOwn(descriptor, 'value') || descriptor.enumerable !== true) {
+    return undefined;
+  }
+  return descriptor.value;
+}
+
+function parseRegistryDocument(value) {
+  const tags = readDataProperty(value, 'dist-tags');
+  const latest = readDataProperty(tags, 'latest');
+  if (!parseSemver(latest)) return undefined;
+  const parsed = { latest };
+  const next = readDataProperty(tags, 'next');
+  if (parseSemver(next)) parsed.next = next;
+  return Object.freeze(parsed);
+}
+
+function isBoundedText(value, maxBytes) {
+  return typeof value === 'string'
+    && value.length > 0
+    && Buffer.byteLength(value, 'utf8') <= maxBytes
+    && !/[\u0000-\u001F\u007F-\u009F\u061C\u200B-\u200F\u202A-\u202E\u2060-\u206F\uFEFF]/u.test(value);
+}
+
+function canonicalOfficialNotesUrl(value) {
+  if (!isBoundedText(value, 2_048)) return undefined;
+  try {
+    const url = new URL(value);
+    const officialHost = url.hostname === 'blun.ai' || url.hostname.endsWith('.blun.ai');
+    if (url.protocol !== 'https:'
+      || !officialHost
+      || url.username !== ''
+      || url.password !== ''
+      || url.port !== '') {
+      return undefined;
+    }
+    return url.href;
+  } catch {
+    return undefined;
+  }
+}
+
+function isIsoTimestamp(value) {
+  if (typeof value !== 'string') return false;
+  const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d{1,3})?Z$/.exec(value);
+  if (!match) {
+    return false;
+  }
+  const timestamp = Date.parse(value);
+  if (!Number.isFinite(timestamp)) return false;
+  const date = new Date(timestamp);
+  return date.getUTCFullYear() === Number(match[1])
+    && date.getUTCMonth() + 1 === Number(match[2])
+    && date.getUTCDate() === Number(match[3])
+    && date.getUTCHours() === Number(match[4])
+    && date.getUTCMinutes() === Number(match[5])
+    && date.getUTCSeconds() === Number(match[6]);
+}
+
+function parseFallbackManifest(value) {
+  const record = exactDataRecord(value, MANIFEST_KEYS);
+  const notesUrl = record ? canonicalOfficialNotesUrl(record.notesUrl) : undefined;
+  if (!record
+    || record.name !== PACKAGE_NAME
+    || !parseSemver(record.latest)
+    || !parseSemver(record.minSupported)
+    || compareSemver(record.minSupported, record.latest) === 1
+    || !isIsoTimestamp(record.releasedAt)
+    || !notesUrl
+    || !isBoundedText(record.install, 256)) {
+    return undefined;
+  }
+  return Object.freeze({
+    name: record.name,
+    latest: record.latest,
+    minSupported: record.minSupported,
+    releasedAt: record.releasedAt,
+    notesUrl,
+    install: record.install,
+  });
+}
+
+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 (!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 (validRegistryLatest && validFallback) {
+    version = compareSemver(validRegistryLatest, validFallback.latest) <= 0
+      ? validRegistryLatest
+      : validFallback.latest;
+  } else {
+    version = validRegistryLatest || validFallback.latest;
+  }
+
+  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 };
+}
+
+function requestTrustedJson(url, options = {}) {
+  const maxBytes = ENDPOINT_LIMITS.get(url);
+  if (maxBytes === undefined) {
+    return Promise.reject(new Error('UNTRUSTED_UPDATE_ENDPOINT'));
+  }
+  const httpsImpl = options.httpsImpl || https;
+  const timeoutMs = options.timeoutMs || REQUEST_TIMEOUT_MS;
+
+  return new Promise((resolve, reject) => {
+    let request;
+    let response;
+    let settled = false;
+    const finish = (error, value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (error) reject(error);
+      else resolve(value);
+    };
+    const timer = setTimeout(() => {
+      const error = new Error('UPDATE_REQUEST_TIMEOUT');
+      finish(error);
+      if (response && typeof response.destroy === 'function') response.destroy();
+      if (request && typeof request.destroy === 'function') request.destroy();
+    }, timeoutMs);
+
+    try {
+      request = httpsImpl.get(url, {
+        headers: { accept: 'application/vnd.npm.install-v1+json, application/json' },
+      }, (incoming) => {
+        response = incoming;
+        if (incoming.statusCode !== 200) {
+          finish(new Error(`UPDATE_HTTP_STATUS_${incoming.statusCode || 0}`));
+          if (typeof incoming.destroy === 'function') incoming.destroy();
+          if (request && typeof request.destroy === 'function') request.destroy();
+          return;
+        }
+
+        const rawLength = incoming.headers && incoming.headers['content-length'];
+        const declaredLength = typeof rawLength === 'string' && /^\d+$/.test(rawLength)
+          ? Number(rawLength)
+          : undefined;
+        if (declaredLength !== undefined && declaredLength > maxBytes) {
+          finish(new Error('UPDATE_BODY_TOO_LARGE'));
+          if (typeof incoming.destroy === 'function') incoming.destroy();
+          return;
+        }
+
+        const chunks = [];
+        let total = 0;
+        incoming.on('data', (chunk) => {
+          if (settled) return;
+          const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+          total += buffer.length;
+          if (total > maxBytes) {
+            finish(new Error('UPDATE_BODY_TOO_LARGE'));
+            if (typeof incoming.destroy === 'function') incoming.destroy();
+            return;
+          }
+          chunks.push(buffer);
+        });
+        incoming.on('error', (error) => finish(error));
+        incoming.on('end', () => {
+          if (settled) return;
+          try {
+            finish(undefined, JSON.parse(Buffer.concat(chunks).toString('utf8')));
+          } catch {
+            finish(new Error('UPDATE_INVALID_JSON'));
+          }
+        });
+      });
+      request.on('error', (error) => finish(error));
+    } catch (error) {
+      finish(error);
+    }
+  });
+}
+
+async function loadReleaseSources() {
+  const [registry, fallback] = await Promise.allSettled([
+    requestTrustedJson(REGISTRY_URL),
+    requestTrustedJson(FALLBACK_MANIFEST_URL),
+  ]);
+  return {
+    registryDocument: registry.status === 'fulfilled' ? registry.value : undefined,
+    fallbackDocument: fallback.status === 'fulfilled' ? fallback.value : undefined,
+  };
+}
+
+function statePath(blunDir) {
+  return path.join(blunDir, STATE_FILE);
+}
+
+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')), [
+      'snoozedUntil',
+      'version',
+    ]);
+    if (!record
+      || record.version !== 1
+      || !Number.isSafeInteger(record.snoozedUntil)
+      || record.snoozedUntil <= now
+      || record.snoozedUntil > now + SNOOZE_MS) {
+      return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function writeSnoozeState(blunDir, now = Date.now()) {
+  ensurePrivateDirectory(blunDir);
+  const filePath = statePath(blunDir);
+  const temporaryPath = path.join(
+    blunDir,
+    `.${STATE_FILE}.${process.pid}.${randomUUID()}.tmp`,
+  );
+  try {
+    writePrivateFile(temporaryPath, `${JSON.stringify({
+      version: 1,
+      snoozedUntil: now + SNOOZE_MS,
+    })}\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
+    && (!env || env.BLUN_NO_AUTO_UPDATE !== '1')
+    && stdin?.isTTY === true
+    && stdout?.isTTY === true;
+}
+
+function installCommandText(version) {
+  return `npm i -g ${PACKAGE_NAME}@${version}`;
+}
+
+function promptUpdateAction({ currentVersion, release, input, output, processRef = process }) {
+  return new Promise((resolve, reject) => {
+    let selected = 1;
+    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 signalHandlers = new Map();
+
+    const renderActions = (refresh) => {
+      if (refresh) output.write('\u001B[2F');
+      for (let index = 0; index < actions.length; index += 1) {
+        output.write(`\r\u001B[2K  ${selected === index ? '>' : ' '} ${actions[index]}\n`);
+      }
+    };
+    const cleanup = () => {
+      if (escapeTimer !== undefined) clearTimeout(escapeTimer);
+      input.removeListener('data', onData);
+      input.removeListener('end', postpone);
+      input.removeListener('close', postpone);
+      input.removeListener('error', postpone);
+      for (const [signal, handler] of signalHandlers) {
+        processRef.removeListener(signal, handler);
+      }
+      signalHandlers.clear();
+      try {
+        if (typeof input.setRawMode === 'function') input.setRawMode(wasRaw);
+      } catch {}
+      try {
+        if (typeof input.pause === 'function') input.pause();
+      } catch {}
+      if (cursorHidden) {
+        try {
+          output.write('\u001B[?25h');
+        } catch {}
+        cursorHidden = false;
+      }
+    };
+    const finish = (choice) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      try {
+        output.write('\n');
+      } catch {}
+      resolve(choice);
+    };
+    const fail = (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(error);
+    };
+    const handleSignal = (signal) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      try {
+        output.write('\n');
+      } catch {}
+      const error = new Error(`UPDATE_PROMPT_${signal}`);
+      error.code = `UPDATE_PROMPT_${signal}`;
+      const exitCode = UPDATE_SIGNAL_EXIT_CODES[signal];
+      processRef.exitCode = exitCode;
+      if (typeof processRef.exit === 'function') processRef.exit(exitCode);
+      reject(error);
+    };
+    function postpone() {
+      finish('postpone');
+    }
+    const waitForEscapeSuffix = () => {
+      if (escapeTimer !== undefined) return;
+      escapeTimer = setTimeout(() => {
+        escapeTimer = undefined;
+        postpone();
+      }, UPDATE_KEY_ESCAPE_TIMEOUT_MS);
+    };
+    const clearEscapeTimer = () => {
+      if (escapeTimer === undefined) return;
+      clearTimeout(escapeTimer);
+      escapeTimer = undefined;
+    };
+    const readEscapeSequence = () => {
+      if (pendingInput.length < 2) return undefined;
+      if (pendingInput[1] === '[') {
+        for (let index = 2; index < pendingInput.length; index += 1) {
+          const code = pendingInput.codePointAt(index);
+          if (code >= 0x40 && code <= 0x7e) return pendingInput.slice(0, index + 1);
+          const isParameter = code >= 0x30 && code <= 0x3f;
+          const isIntermediate = code >= 0x20 && code <= 0x2f;
+          if (!isParameter && !isIntermediate) return pendingInput.slice(0, index + 1);
+        }
+        return pendingInput.length > 64 ? pendingInput : undefined;
+      }
+      if (pendingInput[1] === 'O') {
+        return pendingInput.length >= 3 ? pendingInput.slice(0, 3) : undefined;
+      }
+      return pendingInput.slice(0, 2);
+    };
+    const processPendingInput = () => {
+      while (pendingInput.length > 0) {
+        const first = pendingInput[0];
+        if (first === '\u0003') {
+          postpone();
+          return;
+        }
+        if (first === '\r' || first === '\n') {
+          pendingInput = pendingInput.slice(1);
+          finish(selected === 0 ? 'install' : 'postpone');
+          return;
+        }
+        if (first !== '\u001B') {
+          pendingInput = pendingInput.slice(1);
+          continue;
+        }
+        if (pendingInput.length > 1
+          && (pendingInput[1] === '\r'
+            || pendingInput[1] === '\n'
+            || pendingInput[1] === '\u0003')) {
+          postpone();
+          return;
+        }
+        const sequence = readEscapeSequence();
+        if (sequence === undefined) {
+          waitForEscapeSuffix();
+          return;
+        }
+        clearEscapeTimer();
+        if (sequence === '\u001B[A' || sequence === '\u001B[D') {
+          selected = 0;
+          pendingInput = pendingInput.slice(sequence.length);
+          renderActions(true);
+          continue;
+        }
+        if (sequence === '\u001B[B' || sequence === '\u001B[C') {
+          selected = 1;
+          pendingInput = pendingInput.slice(sequence.length);
+          renderActions(true);
+          continue;
+        }
+        pendingInput = pendingInput.slice(sequence.length);
+      }
+    };
+    const onData = (chunk) => {
+      try {
+        pendingInput += Buffer.isBuffer(chunk) ? decoder.write(chunk) : String(chunk);
+        processPendingInput();
+      } catch (error) {
+        fail(error);
+      }
+    };
+
+    try {
+      const supportedSignals = processRef.platform === 'win32'
+        ? ['SIGINT', 'SIGTERM']
+        : Object.keys(UPDATE_SIGNAL_EXIT_CODES);
+      for (const signal of supportedSignals) {
+        const handler = () => handleSignal(signal);
+        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`);
+      cursorHidden = true;
+      output.write('\u001B[?25l');
+      renderActions(false);
+      input.on('data', onData);
+      input.once('end', postpone);
+      input.once('close', postpone);
+      input.once('error', postpone);
+      if (typeof input.setRawMode === 'function') input.setRawMode(true);
+      if (typeof input.resume === 'function') input.resume();
+    } catch (error) {
+      fail(error);
+    }
+  });
+}
+
+function resolveTrustedNpmCliPath(options = {}) {
+  const execPath = path.resolve(options.execPath || process.execPath);
+  const executableDirectory = path.dirname(execPath);
+  const packageRoot = path.resolve(__dirname, '..');
+  const candidates = options.npmCliPath ? [options.npmCliPath] : [
+    path.join(executableDirectory, 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+    path.resolve(executableDirectory, '..', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+    path.resolve(executableDirectory, '..', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+    path.resolve(packageRoot, '..', 'npm', 'bin', 'npm-cli.js'),
+  ];
+  for (const candidate of candidates) {
+    try {
+      if (!path.isAbsolute(candidate)) continue;
+      const resolved = fs.realpathSync(candidate);
+      const parts = resolved.replaceAll('\\', '/').split('/');
+      const npmIndex = parts.length - 3;
+      if (parts.at(-1) !== 'npm-cli.js'
+        || parts.at(-2) !== 'bin'
+        || parts[npmIndex]?.toLowerCase() !== 'npm'
+        || !fs.statSync(resolved).isFile()) {
+        continue;
+      }
+      return resolved;
+    } catch {}
+  }
+  throw new Error('TRUSTED_NPM_CLI_NOT_FOUND');
+}
+
+function createInstallInvocation(version, options = {}) {
+  if (!parseSemver(version)) throw new Error('INVALID_UPDATE_VERSION');
+  const packageSpec = `${PACKAGE_NAME}@${version}`;
+  const execPath = fs.realpathSync(path.resolve(options.execPath || process.execPath));
+  if (!fs.statSync(execPath).isFile()) throw new Error('INVALID_NODE_EXECUTABLE');
+  const npmCliPath = resolveTrustedNpmCliPath(options);
+  const packageRoot = fs.realpathSync(path.resolve(options.packageRoot));
+  const modulesRoot = path.dirname(packageRoot);
+  if (path.basename(modulesRoot).toLowerCase() !== 'node_modules') {
+    throw new Error('INVALID_GLOBAL_PACKAGE_ROOT');
+  }
+  let installPrefix = path.dirname(modulesRoot);
+  const platform = options.platform || process.platform;
+  if (platform !== 'win32' && path.basename(installPrefix) === 'lib') {
+    installPrefix = path.dirname(installPrefix);
+  }
+  let npmConfigPath;
+  if (options.npmConfigPath) {
+    npmConfigPath = fs.realpathSync(path.resolve(options.npmConfigPath));
+    if (!fs.statSync(npmConfigPath).isFile()) throw new Error('INVALID_NPM_CONFIG_PATH');
+  }
+  return {
+    command: execPath,
+    args: [
+      npmCliPath,
+      'i',
+      '-g',
+      packageSpec,
+      `--registry=${INSTALL_REGISTRY_URL}`,
+      '--strict-ssl=true',
+      '--dry-run=false',
+      '--ignore-scripts=false',
+      '--package-lock-only=false',
+      `--prefix=${installPrefix}`,
+      ...(npmConfigPath ? [
+        `--userconfig=${npmConfigPath}`,
+        `--globalconfig=${npmConfigPath}`,
+      ] : []),
+    ],
+    windowsVerbatimArguments: false,
+  };
+}
+
+function createInstallEnvironment(sourceEnv, installDirectory, npmConfigPath) {
+  const allowedKeys = new Set([
+    'appdata',
+    'comspec',
+    'home',
+    'homedrive',
+    'homepath',
+    'lang',
+    'lc_all',
+    'lc_ctype',
+    'localappdata',
+    'logname',
+    'path',
+    'pathext',
+    'programdata',
+    'programfiles',
+    'programfiles(x86)',
+    'systemroot',
+    'term',
+    'tz',
+    'user',
+    'userprofile',
+    'windir',
+  ]);
+  const result = {};
+  for (const [key, value] of Object.entries(sourceEnv || {})) {
+    const normalized = key.toLowerCase();
+    if (!allowedKeys.has(normalized) && !key.startsWith('BLUN_TEST_')) continue;
+    result[key] = value;
+  }
+  result.TEMP = installDirectory;
+  result.TMP = installDirectory;
+  result.TMPDIR = installDirectory;
+  result.npm_config_registry = INSTALL_REGISTRY_URL;
+  result.npm_config_strict_ssl = 'true';
+  result.npm_config_dry_run = 'false';
+  result.npm_config_ignore_scripts = 'false';
+  result.npm_config_package_lock_only = 'false';
+  result.npm_config_userconfig = npmConfigPath;
+  result.npm_config_globalconfig = npmConfigPath;
+  return result;
+}
+
+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) {
+  try {
+    const manifestPath = path.join(packageRoot, 'package.json');
+    const stat = fs.lstatSync(manifestPath);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 64 * 1024) return false;
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    return readDataProperty(manifest, 'name') === PACKAGE_NAME
+      && readDataProperty(manifest, 'version') === version;
+  } catch {
+    return false;
+  }
+}
+
+function preparePinnedInstaller(version, options = {}) {
+  const forkImpl = options.forkImpl || fork;
+  const preparation = Promise.withResolvers();
+  const resolvePreparation = preparation.resolve;
+    let child;
+    let invocation;
+    let leaseBusy = false;
+    let leaseUnavailable = false;
+    let sendError;
+    let childError;
+    let preparationSettled = false;
+    let closeSettled = false;
+    let selectedAction;
+    let installDirectory;
+    let npmConfigPath;
+    let disconnectTimer;
+    const close = Promise.withResolvers();
+    const closePromise = close.promise;
+    const resolveClose = close.resolve;
+    const cleanupDirectory = () => {
+      try {
+        if (installDirectory) {
+          (options.removeDirectory || fs.rmSync)(installDirectory, {
+            recursive: true,
+            force: true,
+          });
+        }
+      } catch {
+        // Cleanup cannot change a completed npm result.
+      }
+    };
+    const settlePreparation = (result) => {
+      if (preparationSettled) return;
+      preparationSettled = true;
+      clearTimeout(prepareTimeout);
+      resolvePreparation(result);
+    };
+    const finishClose = (result) => {
+      if (closeSettled) return;
+      closeSettled = true;
+      clearTimeout(disconnectTimer);
+      cleanupDirectory();
+      resolveClose(result);
+      if (!preparationSettled) {
+        settlePreparation({
+          ready: false,
+          reason: leaseBusy
+            ? 'busy'
+            : leaseUnavailable
+              ? 'unavailable'
+              : result.code === 75 || result.unknownState === true
+                ? 'unknown'
+                : 'failed',
+          result,
+        });
+      }
+    };
+    const finishDisconnected = () => {
+      if (closeSettled) return;
+      closeSettled = true;
+      const result = { code: undefined, error: childError, unknownState: true };
+      resolveClose(result);
+      if (!preparationSettled) {
+        settlePreparation({ ready: false, reason: 'unknown', result });
+      }
+    };
+    const scheduleUnknownState = (error) => {
+      if (error && childError === undefined) childError = error;
+      if (disconnectTimer !== undefined) return;
+      disconnectTimer = setTimeout(
+        finishDisconnected,
+        options.disconnectTimeoutMs || 1_000,
+      );
+    };
+    const sendControl = (type) => {
+      if (selectedAction) return closePromise;
+      selectedAction = type;
+      try {
+        child.send({ type }, (error) => {
+          if (!error) return;
+          sendError = error;
+          try {
+            child.kill();
+          } catch {}
+        });
+      } catch (error) {
+        sendError = error;
+        try {
+          child.kill();
+        } catch {}
+      }
+      return closePromise;
+    };
+    let prepareTimeout;
+    try {
+      installDirectory = createPrivateInstallDirectory(
+        resolveInstallTempRoot(options),
+        options.blunDir,
+      );
+      npmConfigPath = path.join(installDirectory, 'npmrc');
+      writePrivateFile(npmConfigPath, '');
+      invocation = createInstallInvocation(version, { ...options, npmConfigPath });
+      child = forkImpl(path.join(__dirname, 'update-lease.js'), ['--installer-worker'], {
+        detached: true,
+        execPath: invocation.command,
+        cwd: installDirectory,
+        env: createInstallEnvironment(
+          options.env || process.env,
+          installDirectory,
+          npmConfigPath,
+        ),
+        stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+        windowsHide: true,
+      });
+    } catch (error) {
+      cleanupDirectory();
+      settlePreparation({ ready: false, reason: 'failed', result: { error } });
+      return preparation.promise;
+    }
+    prepareTimeout = setTimeout(() => {
+      sendError = new Error('UPDATE_INSTALLER_PREPARE_TIMEOUT');
+      settlePreparation({ ready: false, reason: 'unknown', result: { error: sendError } });
+      try {
+        child.kill();
+      } catch {}
+    }, options.prepareTimeoutMs || 5_000);
+    prepareTimeout.unref?.();
+    child.once('error', (error) => {
+      if (!preparationSettled && child.pid === undefined) {
+        finishClose({ code: undefined, error });
+        return;
+      }
+      scheduleUnknownState(error);
+    });
+    child.on('message', (message) => {
+      if (message?.type === 'blun-update-lease-busy') leaseBusy = true;
+      if (message?.type === 'blun-update-lease-unavailable') leaseUnavailable = true;
+      if (message?.type === 'blun-update-lease-adopted') {
+        settlePreparation(Object.freeze({
+          ready: true,
+          commit: () => sendControl('blun-update-lease-commit'),
+          cancel: () => sendControl('blun-update-lease-cancel'),
+        }));
+      }
+    });
+    const finishInstallerProcess = (code, signal) => {
+      if (sendError || childError) {
+        finishClose({
+          code: undefined,
+          error: sendError || childError,
+          unknownState: true,
+        });
+        return;
+      }
+      finishClose({
+        code: Number.isInteger(code) ? code : undefined,
+        signal: typeof signal === 'string' ? signal : undefined,
+        leaseBusy,
+        leaseUnavailable,
+        unknownState: !Number.isInteger(code),
+        verified: !leaseBusy
+          && !leaseUnavailable
+          && code === 0
+          && verifyInstalledPackageVersion(options.packageRoot, version),
+      });
+    };
+    child.once('exit', finishInstallerProcess);
+    child.once('close', finishInstallerProcess);
+    child.once('disconnect', () => scheduleUnknownState());
+    try {
+      child.send({
+        type: 'blun-update-lease-handoff',
+        packageRoot: path.resolve(options.packageRoot),
+        installer: {
+          npmCliPath: invocation.args[0],
+          npmArgs: invocation.args.slice(1),
+          installCwd: installDirectory,
+        },
+      }, (error) => {
+        if (!error) return;
+        sendError = error;
+        try {
+          child.kill();
+        } catch {
+          finishClose({ code: undefined, error, unknownState: true });
+        }
+      });
+    } catch (error) {
+      sendError = error;
+      try {
+        child.kill();
+      } catch {
+        finishClose({ code: undefined, error, unknownState: true });
+      }
+    }
+  return preparation.promise;
+}
+
+async function installPinnedVersion(version, options = {}) {
+  const prepared = await preparePinnedInstaller(version, options);
+  if (!prepared.ready) {
+    return {
+      ...prepared.result,
+      leaseBusy: prepared.reason === 'busy',
+      leaseUnavailable: prepared.reason === 'unavailable',
+      unknownState: prepared.reason === 'unknown' || prepared.result?.unknownState === true,
+    };
+  }
+  return prepared.commit();
+}
+
+async function probeInstallLease(options, packageRoot) {
+  let result;
+  try {
+    result = await (options.acquireInstallLease || tryAcquireUpdateLease)({
+      packageRoot,
+      role: 'install',
+    });
+  } catch {
+    return 'unavailable';
+  }
+  if (!result?.acquired) return result?.reason === 'busy' ? 'busy' : 'unavailable';
+  try {
+    result.lease.assertOwned();
+  } catch {
+    return 'busy';
+  } finally {
+    try {
+      await result.lease.release();
+    } catch {}
+  }
+  return 'clear';
+}
+
+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,
+    env,
+    stdin,
+    stdout,
+    stderr,
+    blunDir,
+  } = options;
+  if (!explicitUpdate && !isInteractiveUpdateStart({ argv, env, stdin, stdout })) {
+    return { kind: 'continue', reason: 'not_interactive' };
+  }
+  if (!parseSemver(currentVersion)) {
+    return explicitUpdate
+      ? explicitFailure(stderr, 'invalid_current_version')
+      : { kind: 'continue', reason: 'invalid_current_version' };
+  }
+
+  const now = (options.now || Date.now)();
+  if (!explicitUpdate && readSnoozeState(blunDir, now)) {
+    return { kind: 'continue', reason: 'snoozed' };
+  }
+
+  const packageRoot = path.resolve(options.packageRoot || path.resolve(__dirname, '..'));
+  let leaseResult;
+  const ownsNoticeLease = options.noticeLease === undefined;
+  if (ownsNoticeLease) {
+    try {
+      leaseResult = await (options.acquireLease || tryAcquireUpdateLease)({ packageRoot });
+    } catch {
+      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' };
+  }
+  const { lease } = leaseResult;
+  let installerSession;
+
+  try {
+    if (!explicitUpdate && readSnoozeState(blunDir, (options.now || Date.now)())) {
+      return { kind: 'continue', reason: 'snoozed' };
+    }
+    const initialInstallLease = await probeInstallLease(options, packageRoot);
+    if (initialInstallLease === 'busy') {
+      return explicitUpdate
+        ? explicitFailure(stderr, 'update_in_progress')
+        : { kind: 'update_in_progress' };
+    }
+    if (initialInstallLease !== 'clear') {
+      return explicitUpdate
+        ? explicitFailure(stderr, 'lease_unavailable')
+        : { kind: 'continue', reason: 'lease_unavailable' };
+    }
+    let sources;
+    try {
+      sources = await (options.loadReleaseSources || loadReleaseSources)();
+    } catch {
+      return explicitUpdate
+        ? explicitNoTarget(stdout, 'unavailable')
+        : { kind: 'continue', reason: 'unavailable' };
+    }
+    const registryTags = parseRegistryDocument(sources?.registryDocument);
+    const fallbackManifest = parseFallbackManifest(sources?.fallbackDocument);
+    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 explicitUpdate
+        ? explicitFailure(stderr, 'update_in_progress')
+        : { kind: 'update_in_progress' };
+    }
+    const prePromptInstallLease = await probeInstallLease(options, packageRoot);
+    if (prePromptInstallLease === 'busy') {
+      return explicitUpdate
+        ? explicitFailure(stderr, 'update_in_progress')
+        : { kind: 'update_in_progress' };
+    }
+    if (prePromptInstallLease !== 'clear') {
+      return explicitUpdate
+        ? explicitFailure(stderr, 'lease_unavailable')
+        : { kind: 'continue', reason: 'lease_unavailable' };
+    }
+    if (!options.installVersion) {
+      installerSession = await (options.prepareInstaller || preparePinnedInstaller)(
+        release.version,
+        { 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;
+    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();
+      try {
+        writeSnoozeState(blunDir, (options.now || Date.now)());
+      } catch {
+        // A failed preference write must not block the existing console.
+      }
+      return { kind: 'continue', reason: 'postponed' };
+    }
+
+    try {
+      lease.assertOwned();
+    } catch {
+      return explicitUpdate
+        ? explicitFailure(stderr, 'update_in_progress')
+        : { kind: 'update_in_progress' };
+    }
+    let installResult;
+    try {
+      installResult = options.installVersion
+        ? await options.installVersion(release.version)
+        : await installerSession.commit();
+    } catch {
+      installResult = { code: undefined };
+    }
+    if (installResult?.leaseBusy === true
+      || installResult?.leaseUnavailable === true
+      || installResult?.unknownState === true) {
+      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');
+      return { kind: 'installed', version: release.version };
+    }
+
+    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 {
+    if (installerSession?.ready) {
+      try {
+        await installerSession.cancel();
+      } catch {}
+    }
+    if (ownsNoticeLease) {
+      try {
+        await lease.release();
+      } catch {}
+    }
+  }
+}
+
+function runExplicitUpdate(options) {
+  return runUpdateFlow(options, true);
+}
+
+function runUpdateNotice(options) {
+  return runUpdateFlow(options, false);
+}
+
+module.exports = {
+  FALLBACK_MANIFEST_URL,
+  PACKAGE_NAME,
+  REGISTRY_URL,
+  SNOOZE_MS,
+  compareSemver,
+  createInstallInvocation,
+  installPinnedVersion,
+  preparePinnedInstaller,
+  isInteractiveUpdateStart,
+  loadReleaseSources,
+  parseFallbackManifest,
+  parseRegistryDocument,
+  promptUpdateAction,
+  readSnoozeState,
+  requestTrustedJson,
+  resolveEffectiveRelease,
+  runExplicitUpdate,
+  runUpdateNotice,
+  writeSnoozeState,
+};