Upload via GUI (39 Dateien)

2026-08-02 17:01:18 +02:00
parent a803f297ea
commit eff6403dd5
26 changed files with 3536 additions and 134 deletions
@@ -17,20 +17,117 @@ const { spawn } = require('child_process');
 const API = 'https://git.viper.ipv64.net/api/v1/repos/M_Viper/AeroMc-Launcher/releases';
 const UA = 'AeroMC-Launcher';

+/*
+ * Paketart der laufenden Anwendung: 'portable', 'setup' oder 'unknown'.
+ *
+ * Wichtig: es wird nie geraten. Portable-Nutzer dürfen niemals einen Installer
+ * bekommen und Setup-Nutzer niemals eine Portable-Datei – im Zweifel lieber
+ * 'unknown' und gar kein automatisches Update anbieten.
+ */
+let cachedKind = null;
 function detectInstallKind() {
-  const portableExe = String(process.env.PORTABLE_EXECUTABLE_FILE || '').trim();
-  const execName = path.basename(portableExe || process.execPath || '').toLowerCase();
-  if (portableExe || execName.includes('portable')) return 'portable';
-  return 'setup';
+  if (cachedKind) return cachedKind;
+  cachedKind = computeInstallKind();
+  return cachedKind;
 }

-// "1.2.3" -> [1,2,3]; führendes "v" und Zusätze wie "-beta" werden ignoriert
+function computeInstallKind() {
+  // 1. Portable: diese Variablen setzt ausschließlich der Portable-Build von
+  //    electron-builder – das ist das verlässlichste Signal überhaupt.
+  if (String(process.env.PORTABLE_EXECUTABLE_FILE || '').trim()) return 'portable';
+  if (String(process.env.PORTABLE_EXECUTABLE_DIR || '').trim()) return 'portable';
+  if (String(process.env.PORTABLE_EXECUTABLE_APP_FILENAME || '').trim()) return 'portable';
+
+  const exe = process.execPath || '';
+  // 2. Notnagel über den Dateinamen, falls die Variablen einmal fehlen
+  if (/portable/i.test(path.basename(exe))) return 'portable';
+
+  // 3. Setup: NSIS legt neben der EXE immer einen Uninstaller ab. Nur wenn der
+  //    da ist, ist es wirklich eine Installation.
+  if (hasUninstaller(path.dirname(exe))) return 'setup';
+
+  // 4. Alles andere (Entwicklungsmodus, entpackter Ordner, unbekannte Kopie)
+  return 'unknown';
+}
+
+function hasUninstaller(dir) {
+  try {
+    return fs.readdirSync(dir).some((n) => /^unins(tall)?.*\.exe$/i.test(n));
+  } catch {
+    return false;
+  }
+}
+
+// Pfad der laufenden Portable-EXE (die Datei, die der Nutzer selbst gestartet hat)
+function portableTarget() {
+  const p = String(process.env.PORTABLE_EXECUTABLE_FILE || '').trim();
+  if (p) return p;
+  // Fallback: nur brauchbar, wenn die EXE nicht entpackt ausgeführt wird
+  const exe = process.execPath || '';
+  return path.basename(exe).toLowerCase().includes('portable') ? exe : '';
+}
+
+function updateDir() {
+  return path.join(os.tmpdir(), 'aeromc-update');
+}
+
+/*
+ * Räumt Reste alter Update-Vorgänge weg (Installer sind mehrere hundert MB groß).
+ * Dateien, die jünger als 10 Minuten sind, bleiben liegen – sie könnten gerade
+ * von einem laufenden Update benutzt werden.
+ */
+function cleanupUpdateCache() {
+  try {
+    const dir = updateDir();
+    if (!fs.existsSync(dir)) return;
+    for (const name of fs.readdirSync(dir)) {
+      const p = path.join(dir, name);
+      try {
+        if (Date.now() - fs.statSync(p).mtimeMs < 600000) continue;
+        fs.rmSync(p, { force: true, recursive: true });
+      } catch { /* gesperrt – beim nächsten Start erneut versuchen */ }
+    }
+  } catch { /* egal */ }
+}
+
+// "v1.2.3-beta.2" -> [1,2,3]; führendes "v" wird ignoriert
 function parseVersion(v) {
  const m = String(v || '').trim().replace(/^v/i, '').match(/^(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
  if (!m) return null;
  return [Number(m[1] || 0), Number(m[2] || 0), Number(m[3] || 0)];
 }

+// Vorabkennung hinter dem ersten "-", z. B. "beta" oder "beta.2"
+function parsePreRelease(v) {
+  const m = String(v || '').trim().replace(/^v/i, '').match(/^\d+(?:\.\d+){0,2}-([0-9A-Za-z.\-]+)/);
+  return m ? m[1].split('.') : null;
+}
+
+/*
+ * Vergleicht die Vorabkennungen zweier gleicher Versionsnummern.
+ *
+ * Bewusst nicht streng nach SemVer: trägt ein Release-Tag die Vorabkennung
+ * nicht, die die App selbst meldet (Tag "1.0.1" gegen App "1.0.1-beta"),
+ * würde "1.0.1" als neuer gelten – der Launcher böte dasselbe Update nach
+ * jeder Installation erneut an, eine Endlosschleife. Deshalb zählt eine
+ * Vorabkennung nur, wenn sie auf beiden Seiten vorhanden ist (beta.1 -> beta.2).
+ */
+function comparePreRelease(a, b) {
+  if (!a || !b) return 0;
+  for (let i = 0; i < Math.max(a.length, b.length); i++) {
+    const x = a[i]; const y = b[i];
+    if (x === undefined) return -1;
+    if (y === undefined) return 1;
+    const nx = /^\d+$/.test(x) ? Number(x) : null;
+    const ny = /^\d+$/.test(y) ? Number(y) : null;
+    if (nx !== null && ny !== null) { if (nx !== ny) return nx - ny; continue; }
+    if (nx !== null) return -1;   // Zahlen zählen weniger als Text
+    if (ny !== null) return 1;
+    if (x !== y) return x < y ? -1 : 1;
+  }
+  return 0;
+}
+
 // >0 wenn a neuer als b
 function compareVersions(a, b) {
  const x = parseVersion(a); const y = parseVersion(b);
@@ -38,24 +135,31 @@ function compareVersions(a, b) {
  for (let i = 0; i < 3; i++) {
    if (x[i] !== y[i]) return x[i] - y[i];
  }
-  return 0;
+  return comparePreRelease(parsePreRelease(a), parsePreRelease(b));
 }

-function isPortableAsset(name) {
-  return /portable/i.test(name) && /\.exe$/i.test(name);
-}
-
-function isSetupAsset(name) {
-  return /setup/i.test(name) && /\.exe$/i.test(name);
+/*
+ * Paketart einer Release-Datei am Namen erkennen: 'portable', 'setup' oder null.
+ * Namen, die auf beides passen (z. B. "AeroMC-Portable-Setup.exe"), gelten als
+ * mehrdeutig und werden bewusst niemandem angeboten – lieber kein Update als
+ * das falsche.
+ */
+function assetKind(name) {
+  const n = String(name || '');
+  if (!/\.exe$/i.test(n)) return null;
+  const portable = /portable/i.test(n);
+  const setup = /setup|install(er)?/i.test(n);
+  if (portable && setup) return null;
+  if (portable) return 'portable';
+  if (setup) return 'setup';
+  return null;   // ohne Kennzeichnung im Namen nicht zuzuordnen
 }

 // passendes Windows-Artefakt im Release finden
 function pickAsset(release, installKind) {
+  if (installKind !== 'portable' && installKind !== 'setup') return null;
  const assets = release.assets || [];
-  if (installKind === 'portable') {
-    return assets.find((a) => isPortableAsset(a.name)) || null;
-  }
-  return assets.find((a) => isSetupAsset(a.name)) || null;
+  return assets.find((a) => assetKind(a.name) === installKind) || null;
 }

 /*
@@ -88,6 +192,25 @@ async function checkForUpdate(currentVersion) {
  };
 }

+/*
+ * Wirft, sobald eine Datei nicht zweifelsfrei zur laufenden Paketart gehört.
+ * Wird vor dem Download und noch einmal direkt vor dem Ausführen aufgerufen.
+ */
+function assertMatchingKind(fileName, installKind) {
+  if (installKind !== 'portable' && installKind !== 'setup') {
+    throw new Error('Die Paketart des Launchers lässt sich nicht sicher bestimmen – bitte manuell aktualisieren.');
+  }
+  const kind = assetKind(fileName);
+  if (!kind) {
+    throw new Error(`"${fileName}" lässt sich keiner Paketart zuordnen – bitte manuell aktualisieren.`);
+  }
+  if (kind !== installKind) {
+    const soll = installKind === 'portable' ? 'eine Portable-Datei' : 'einen Installer';
+    const ist = kind === 'portable' ? 'eine Portable-Datei' : 'ein Installer';
+    throw new Error(`Falsches Paket: Dieser Launcher braucht ${soll}, angeboten wurde ${ist}.`);
+  }
+}
+
 /*
 * Lädt den Installer herunter (mit Fortschritt) und startet ihn.
 * onProgress: ({ phase, loaded, total, percent })
@@ -95,42 +218,143 @@ async function checkForUpdate(currentVersion) {
 async function downloadAndInstall(asset, onProgress) {
  if (!asset || !asset.url) throw new Error('Kein Installer im Release gefunden.');
  const installKind = detectInstallKind();
-  if (asset.kind && asset.kind !== installKind) {
-    throw new Error('Das angebotene Update passt nicht zur laufenden Paketart.');
+  // Paketart am echten Dateinamen prüfen, nicht am mitgelieferten Feld –
+  // sonst kontrolliert sich die Angabe nur selbst.
+  assertMatchingKind(asset.name, installKind);
+
+  // Portable-Updates ersetzen später die laufende EXE – das geht nur, wenn wir sie kennen
+  const target = installKind === 'portable' ? portableTarget() : '';
+  if (installKind === 'portable' && !target) {
+    throw new Error('Der Pfad der laufenden Portable-Datei ist unbekannt – bitte manuell aktualisieren.');
  }

-  const dir = path.join(os.tmpdir(), 'aeromc-update');
+  const dir = updateDir();
  fs.mkdirSync(dir, { recursive: true });
  const dest = path.join(dir, asset.name.replace(/[^\w.\-]/g, '_'));
+  fs.rmSync(dest, { force: true });

  const res = await fetch(asset.url, { headers: { 'User-Agent': UA } });
  if (!res.ok) throw new Error('Download fehlgeschlagen: HTTP ' + res.status);

  const total = Number(res.headers.get('content-length')) || asset.size || 0;
-  const chunks = [];
+
+  // direkt auf die Platte schreiben statt alles im Speicher zu sammeln
+  const out = fs.createWriteStream(dest);
+  const hash = crypto.createHash('sha256');
  let loaded = 0;
-  for await (const chunk of res.body) {
-    chunks.push(Buffer.from(chunk));
-    loaded += chunk.length;
-    if (onProgress) {
-      onProgress({ phase: 'download', loaded, total, percent: total ? Math.round((loaded / total) * 100) : 0 });
+  let lastReport = 0;
+  try {
+    for await (const chunk of res.body) {
+      const buf = Buffer.from(chunk);
+      hash.update(buf);
+      loaded += buf.length;
+      // auf den Puffer warten; der jeweils andere Listener wird mit abgeräumt,
+      // sonst sammeln sich über den ganzen Download hunderte davon an
+      if (!out.write(buf)) await new Promise((resolve, reject) => {
+        const onDrain = () => { out.off('error', onError); resolve(); };
+        const onError = (e) => { out.off('drain', onDrain); reject(e); };
+        out.once('drain', onDrain);
+        out.once('error', onError);
+      });
+      // höchstens viermal pro Sekunde melden, sonst flutet es die Oberfläche
+      if (onProgress && Date.now() - lastReport >= 250) {
+        lastReport = Date.now();
+        onProgress({ phase: 'download', loaded, total, percent: total ? Math.round((loaded / total) * 100) : 0 });
+      }
    }
+    await new Promise((resolve, reject) => {
+      out.once('error', reject);
+      out.end((err) => (err ? reject(err) : resolve()));
+    });
+  } catch (err) {
+    out.destroy();
+    fs.rmSync(dest, { force: true });
+    throw err;
  }
-  const buf = Buffer.concat(chunks);
-  if (total && buf.length !== total) throw new Error('Download unvollständig.');
-  fs.writeFileSync(dest, buf);

-  const sha256 = crypto.createHash('sha256').update(buf).digest('hex');
-  if (onProgress) onProgress({ phase: 'ready', loaded: buf.length, total: buf.length, percent: 100 });
+  if (total && loaded !== total) {
+    fs.rmSync(dest, { force: true });
+    throw new Error('Download unvollständig.');
+  }

-  return { path: dest, bytes: buf.length, sha256 };
+  if (onProgress) onProgress({ phase: 'ready', loaded, total: loaded, percent: 100 });
+  return { path: dest, bytes: loaded, sha256: hash.digest('hex'), kind: installKind, target };
 }

-// Startet den Installer und löst sich vom Launcher (damit er sich selbst ersetzen kann)
-function runInstaller(installerPath) {
-  const child = spawn(installerPath, [], { detached: true, stdio: 'ignore' });
+/*
+ * Hilfsskript für Portable-Updates: wartet, bis der Launcher die eigene EXE
+ * freigibt, tauscht sie gegen die neue aus und startet sie wieder.
+ * "ping" statt "timeout", weil timeout ohne Konsole abbricht.
+ */
+const SWAP_SCRIPT = `@echo off
+setlocal
+set "SRC=%~1"
+set "DST=%~2"
+set "LOG=%~dp0update.log"
+set TRIES=0
+:loop
+ping -n 2 127.0.0.1 >nul
+copy /y "%SRC%" "%DST%" >nul 2>&1
+if not errorlevel 1 goto done
+set /a TRIES+=1
+if %TRIES% GEQ 60 goto fail
+goto loop
+:done
+del /f /q "%SRC%" >nul 2>&1
+start "" "%DST%"
+exit /b 0
+:fail
+echo [%DATE% %TIME%] Konnte "%DST%" nicht ersetzen - Datei gesperrt oder schreibgeschuetzt.>>"%LOG%"
+exit /b 1
+`;
+
+/*
+ * Wendet das geladene Update an.
+ * setup    -> NSIS-Installer starten, er überschreibt die Installation selbst
+ * portable -> Skript starten, das die laufende EXE nach dem Beenden ersetzt
+ * Der Launcher muss sich danach beenden.
+ */
+function applyUpdate(file) {
+  const installKind = detectInstallKind();
+  // letzte Kontrolle unmittelbar vor dem Start: passt die Datei auf der Platte
+  // wirklich zu dieser Paketart?
+  assertMatchingKind(path.basename(file.path || ''), installKind);
+  const kind = installKind;
+
+  if (kind !== 'portable') {
+    const child = spawn(file.path, [], { detached: true, stdio: 'ignore' });
+    child.unref();
+    return { started: 'installer' };
+  }
+
+  const target = file.target || portableTarget();
+  if (!target) throw new Error('Der Pfad der laufenden Portable-Datei ist unbekannt.');
+
+  const script = path.join(updateDir(), 'aeromc-swap.cmd');
+  fs.writeFileSync(script, SWAP_SCRIPT, 'ascii');
+
+  // über "start /min", damit kein Konsolenfenster im Vordergrund stehen bleibt
+  const child = spawn(process.env.COMSPEC || 'cmd.exe',
+    ['/c', 'start', '', '/min', script, file.path, target],
+    { detached: true, stdio: 'ignore', windowsHide: true });
  child.unref();
-  return true;
+  return { started: 'swap', target };
 }

-module.exports = { checkForUpdate, downloadAndInstall, runInstaller, compareVersions, parseVersion, detectInstallKind };
+// Rückwärtskompatibel: nur für die Setup-Variante
+function runInstaller(installerPath) {
+  return applyUpdate({ path: installerPath, kind: 'setup' });
+}
+
+module.exports = {
+  checkForUpdate,
+  downloadAndInstall,
+  applyUpdate,
+  runInstaller,
+  cleanupUpdateCache,
+  compareVersions,
+  parseVersion,
+  detectInstallKind,
+  assetKind,
+  portableTarget,
+};