blun-king-cli 9.1.587 → 9.1.588

package/bin/update-copy.js

@@ -0,0 +1,200 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const UPDATE_LOCALES = Object.freeze(['en', 'de', 'es', 'fr', 'sv', 'cs']);
+const UPDATE_LOCALE_SET = new Set(UPDATE_LOCALES);
+const MAX_TUI_CONFIG_BYTES = 64 * 1024;
+
+const UPDATE_COPY = Object.freeze({
+  en: Object.freeze({
+    available: 'BLUN Code update available: {currentVersion} -> {targetVersion}',
+    releaseNotes: 'Release notes:',
+    install: 'Update now (runs `{command}`)',
+    skipOnce: 'Skip for now',
+    skipVersion: 'Wait for the next release',
+    confirm: 'Press Enter to continue',
+    noUpdate: 'No update available. Installed: {currentVersion} · Latest: {currentVersion}.',
+    noTarget: 'No verified version is available for the update. Installed: {currentVersion}.',
+    failedCode: 'Update failed (code {exitCode}).',
+    verifyFailed: 'The update could not be verified.',
+    queued: 'Update {targetVersion} queued. It will be installed automatically at startup as soon as possible.',
+    progressChecked: 'Update checked',
+    installerReady: 'Installer ready',
+    installing: 'Installing package',
+    installVerified: 'Installation verified',
+    stateWarning: 'Update {targetVersion} was installed, but the startup notification could not be saved.',
+    success: 'Update {currentVersion} -> {targetVersion} installed successfully. Restart BLUN Code to use the new version.',
+    failedContinue: 'Update failed (code {exitCode}). The installed version will start.',
+    verifyRestart: 'The update could not be verified. Restart BLUN Code.',
+    availableManual: 'BLUN Code update available: {currentVersion} -> {targetVersion}. Run `{command}`.',
+  }),
+  de: Object.freeze({
+    available: 'BLUN-Code-Update verfügbar: {currentVersion} -> {targetVersion}',
+    releaseNotes: 'Versionshinweise:',
+    install: 'Jetzt aktualisieren (führt `{command}` aus)',
+    skipOnce: 'Für diesen Start überspringen',
+    skipVersion: 'Auf die nächste Version warten',
+    confirm: 'Drücken Sie die Eingabetaste, um fortzufahren',
+    noUpdate: 'Kein Update verfügbar. Installiert: {currentVersion} · Aktuell: {currentVersion}.',
+    noTarget: 'Keine verifizierte Zielversion für das Update verfügbar. Installiert: {currentVersion}.',
+    failedCode: 'Update fehlgeschlagen (Code {exitCode}).',
+    verifyFailed: 'Das Update konnte nicht verifiziert werden.',
+    queued: 'Update {targetVersion} vorgemerkt. Es wird beim Start automatisch installiert, sobald dies möglich ist.',
+    progressChecked: 'Update geprüft',
+    installerReady: 'Installationsprogramm bereit',
+    installing: 'Paket wird installiert',
+    installVerified: 'Installation geprüft',
+    stateWarning: 'Update {targetVersion} wurde installiert, aber die Startmeldung konnte nicht gespeichert werden.',
+    success: 'Update {currentVersion} -> {targetVersion} erfolgreich installiert. Starten Sie BLUN Code neu, um die neue Version zu verwenden.',
+    failedContinue: 'Update fehlgeschlagen (Code {exitCode}). Die installierte Version wird gestartet.',
+    verifyRestart: 'Das Update konnte nicht verifiziert werden. Starten Sie BLUN Code neu.',
+    availableManual: 'BLUN-Code-Update verfügbar: {currentVersion} -> {targetVersion}. Führen Sie `{command}` aus.',
+  }),
+  es: Object.freeze({
+    available: 'Actualización de BLUN Code disponible: {currentVersion} -> {targetVersion}',
+    releaseNotes: 'Notas de la versión:',
+    install: 'Actualizar ahora (ejecuta `{command}`)',
+    skipOnce: 'Omitir por ahora',
+    skipVersion: 'Esperar a la próxima versión',
+    confirm: 'Pulsa Intro para continuar',
+    noUpdate: 'No hay ninguna actualización disponible. Versión instalada: {currentVersion} · Última versión: {currentVersion}.',
+    noTarget: 'No hay ninguna versión verificada disponible para actualizar. Versión instalada: {currentVersion}.',
+    failedCode: 'Error al actualizar (código {exitCode}).',
+    verifyFailed: 'No se pudo verificar la actualización.',
+    queued: 'Actualización {targetVersion} puesta en cola. Se instalará automáticamente al iniciar BLUN Code en cuanto sea posible.',
+    progressChecked: 'Actualización comprobada',
+    installerReady: 'Instalador listo',
+    installing: 'Instalando paquete',
+    installVerified: 'Instalación verificada',
+    stateWarning: 'Se instaló la actualización {targetVersion}, pero no se pudo guardar el aviso de inicio.',
+    success: 'La actualización {currentVersion} -> {targetVersion} se instaló correctamente. Reinicia BLUN Code para usar la nueva versión.',
+    failedContinue: 'Error al actualizar (código {exitCode}). Se iniciará la versión instalada.',
+    verifyRestart: 'No se pudo verificar la actualización. Reinicia BLUN Code.',
+    availableManual: 'Actualización de BLUN Code disponible: {currentVersion} -> {targetVersion}. Ejecuta `{command}`.',
+  }),
+  fr: Object.freeze({
+    available: 'Mise à jour de BLUN Code disponible : {currentVersion} -> {targetVersion}',
+    releaseNotes: 'Notes de version :',
+    install: 'Mettre à jour maintenant (exécute `{command}`)',
+    skipOnce: 'Ignorer pour le moment',
+    skipVersion: 'Attendre la prochaine version',
+    confirm: 'Appuyez sur Entrée pour continuer',
+    noUpdate: 'Aucune mise à jour disponible. Version installée : {currentVersion} · Dernière version : {currentVersion}.',
+    noTarget: 'Aucune version cible vérifiée n’est disponible pour la mise à jour. Version installée : {currentVersion}.',
+    failedCode: 'Échec de la mise à jour (code {exitCode}).',
+    verifyFailed: 'La mise à jour n’a pas pu être vérifiée.',
+    queued: 'Mise à jour {targetVersion} en attente. Elle sera installée automatiquement au démarrage de BLUN Code dès que possible.',
+    progressChecked: 'Mise à jour vérifiée',
+    installerReady: 'Programme d’installation prêt',
+    installing: 'Installation du paquet',
+    installVerified: 'Installation vérifiée',
+    stateWarning: 'La mise à jour {targetVersion} a été installée, mais la notification de démarrage n’a pas pu être enregistrée.',
+    success: 'La mise à jour {currentVersion} -> {targetVersion} a été installée. Redémarrez BLUN Code pour utiliser la nouvelle version.',
+    failedContinue: 'Échec de la mise à jour (code {exitCode}). La version installée va démarrer.',
+    verifyRestart: 'La mise à jour n’a pas pu être vérifiée. Redémarrez BLUN Code.',
+    availableManual: 'Mise à jour de BLUN Code disponible : {currentVersion} -> {targetVersion}. Exécutez `{command}`.',
+  }),
+  sv: Object.freeze({
+    available: 'BLUN Code-uppdatering tillgänglig: {currentVersion} -> {targetVersion}',
+    releaseNotes: 'Versionsinformation:',
+    install: 'Uppdatera nu (kör `{command}`)',
+    skipOnce: 'Hoppa över nu',
+    skipVersion: 'Vänta på nästa version',
+    confirm: 'Tryck på Enter för att fortsätta',
+    noUpdate: 'Ingen uppdatering är tillgänglig. Installerad version: {currentVersion} · Senaste version: {currentVersion}.',
+    noTarget: 'Det finns ingen verifierad version att uppdatera till. Installerad version: {currentVersion}.',
+    failedCode: 'Uppdateringen misslyckades (kod {exitCode}).',
+    verifyFailed: 'Uppdateringen kunde inte verifieras.',
+    queued: 'Uppdatering {targetVersion} står i kö. Den installeras automatiskt när BLUN Code startar, så snart det är möjligt.',
+    progressChecked: 'Uppdateringen har kontrollerats',
+    installerReady: 'Installationsprogrammet är klart',
+    installing: 'Installerar paket',
+    installVerified: 'Installationen har verifierats',
+    stateWarning: 'Uppdatering {targetVersion} installerades, men startmeddelandet kunde inte sparas.',
+    success: 'Uppdatering {currentVersion} -> {targetVersion} installerades. Starta om BLUN Code för att använda den nya versionen.',
+    failedContinue: 'Uppdateringen misslyckades (kod {exitCode}). Den installerade versionen startas.',
+    verifyRestart: 'Uppdateringen kunde inte verifieras. Starta om BLUN Code.',
+    availableManual: 'BLUN Code-uppdatering tillgänglig: {currentVersion} -> {targetVersion}. Kör `{command}`.',
+  }),
+  cs: Object.freeze({
+    available: 'K dispozici je aktualizace BLUN Code: {currentVersion} -> {targetVersion}',
+    releaseNotes: 'Poznámky k verzi:',
+    install: 'Aktualizovat nyní (spustí `{command}`)',
+    skipOnce: 'Nyní přeskočit',
+    skipVersion: 'Počkat na další verzi',
+    confirm: 'Pokračujte stisknutím klávesy Enter',
+    noUpdate: 'Žádná aktualizace není k dispozici. Nainstalováno: {currentVersion} · Nejnovější: {currentVersion}.',
+    noTarget: 'Není k dispozici žádná ověřená cílová verze aktualizace. Nainstalováno: {currentVersion}.',
+    failedCode: 'Aktualizace se nezdařila (kód {exitCode}).',
+    verifyFailed: 'Aktualizaci se nepodařilo ověřit.',
+    queued: 'Aktualizace {targetVersion} byla zařazena do fronty. Nainstaluje se automaticky při spuštění BLUN Code, jakmile to bude možné.',
+    progressChecked: 'Aktualizace zkontrolována',
+    installerReady: 'Instalační program je připraven',
+    installing: 'Instalace balíčku',
+    installVerified: 'Instalace ověřena',
+    stateWarning: 'Aktualizace {targetVersion} byla nainstalována, ale oznámení po spuštění se nepodařilo uložit.',
+    success: 'Aktualizace {currentVersion} -> {targetVersion} byla úspěšně nainstalována. Chcete-li používat novou verzi, restartujte BLUN Code.',
+    failedContinue: 'Aktualizace se nezdařila (kód {exitCode}). Spustí se nainstalovaná verze.',
+    verifyRestart: 'Aktualizaci se nepodařilo ověřit. Restartujte BLUN Code.',
+    availableManual: 'K dispozici je aktualizace BLUN Code: {currentVersion} -> {targetVersion}. Spusťte `{command}`.',
+  }),
+});
+
+function normalizeUpdateLocale(value) {
+  if (typeof value !== 'string') return undefined;
+  const normalized = value.trim().split(/[:.@]/u, 1)[0].replaceAll('_', '-').toLowerCase().split('-')[0];
+  return UPDATE_LOCALE_SET.has(normalized) ? normalized : undefined;
+}
+
+function readConfiguredUpdateLocale(blunDir) {
+  try {
+    const filename = path.join(blunDir, 'tui.toml');
+    const stat = fs.lstatSync(filename);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > MAX_TUI_CONFIG_BYTES) {
+      return undefined;
+    }
+    const source = fs.readFileSync(filename, 'utf8').replace(/^\uFEFF/u, '');
+    for (const line of source.split(/\r?\n/u)) {
+      if (/^\s*\[/u.test(line)) break;
+      const match = /^\s*ui_locale\s*=\s*(["'])(auto|[a-z]{2})\1\s*(?:#.*)?$/iu.exec(line);
+      if (match) return match[2].toLowerCase();
+    }
+  } catch {}
+  return undefined;
+}
+
+function resolveUpdateLocale(options = {}) {
+  const configured = readConfiguredUpdateLocale(options.blunDir || '');
+  if (configured && configured !== 'auto') return normalizeUpdateLocale(configured) || 'en';
+  const env = options.env || process.env;
+  const candidates = [env.LC_ALL, env.LC_MESSAGES, env.LANG, options.systemLocale];
+  if (!Object.hasOwn(options, 'systemLocale')) {
+    try {
+      candidates.push(Intl.DateTimeFormat().resolvedOptions().locale);
+    } catch {}
+  }
+  for (const candidate of candidates) {
+    if (typeof candidate === 'string' && candidate.trim()) return normalizeUpdateLocale(candidate) || 'en';
+  }
+  return 'en';
+}
+
+function updateText(locale, key, replacements = {}) {
+  const catalog = UPDATE_COPY[normalizeUpdateLocale(locale) || 'en'];
+  const template = catalog[key] || UPDATE_COPY.en[key];
+  if (typeof template !== 'string') throw new Error(`UNKNOWN_UPDATE_COPY_KEY:${key}`);
+  return template.replace(/\{([A-Za-z][A-Za-z0-9]*)\}/gu, (placeholder, name) => (
+    Object.hasOwn(replacements, name) ? String(replacements[name]) : placeholder
+  ));
+}
+
+module.exports = {
+  UPDATE_COPY,
+  UPDATE_LOCALES,
+  normalizeUpdateLocale,
+  readConfiguredUpdateLocale,
+  resolveUpdateLocale,
+  updateText,
+};