453 lines
17 KiB
JavaScript
453 lines
17 KiB
JavaScript
const fs = require('fs');
|
|
const path = require('path');
|
|
const crypto = require('crypto');
|
|
const { setTimeout: delay } = require('node:timers/promises');
|
|
const { app } = require('electron');
|
|
|
|
const UPDATE_REPO = 'Administrator/Multi-Hoster-Upload';
|
|
const GITEA_BASE = 'https://git.24-music.de';
|
|
const API_URL = `${GITEA_BASE}/api/v1/repos/${UPDATE_REPO}/releases?limit=1`;
|
|
const GITHUB_RELEASE_URL = 'https://api.github.com/repos/Sucukdeluxe/Multi-Hoster-Upload/releases/tags';
|
|
|
|
const CHECK_TIMEOUT = 15000;
|
|
|
|
let cachedCheck = null;
|
|
let cachedCheckTs = 0;
|
|
const CACHE_TTL = 10 * 60 * 1000; // 10 min
|
|
|
|
let activeAbort = null;
|
|
const launchedInstallerPaths = new Set();
|
|
|
|
function createUpdateAnnouncementState() {
|
|
let announcedVersion = '';
|
|
|
|
function versionOf(update) {
|
|
return String(update?.remoteVersion || '').replace(/^v/i, '').trim();
|
|
}
|
|
|
|
return Object.freeze({
|
|
canAnnounce(update, rendererReady) {
|
|
const version = versionOf(update);
|
|
return Boolean(rendererReady && update?.available && version && version !== announcedVersion);
|
|
},
|
|
markAnnounced(update) {
|
|
announcedVersion = versionOf(update);
|
|
},
|
|
reset() {
|
|
announcedVersion = '';
|
|
}
|
|
});
|
|
}
|
|
|
|
function getCurrentVersion() {
|
|
return app.getVersion();
|
|
}
|
|
|
|
function parseVersion(str) {
|
|
const clean = String(str || '').replace(/^v/i, '').trim();
|
|
const parts = clean.split('.').map(Number);
|
|
return {
|
|
major: parts[0] || 0,
|
|
minor: parts[1] || 0,
|
|
patch: parts[2] || 0
|
|
};
|
|
}
|
|
|
|
function isNewer(remote, current) {
|
|
const r = parseVersion(remote);
|
|
const c = parseVersion(current);
|
|
if (r.major !== c.major) return r.major > c.major;
|
|
if (r.minor !== c.minor) return r.minor > c.minor;
|
|
return r.patch > c.patch;
|
|
}
|
|
|
|
function resolveReleaseVersion(release) {
|
|
for (const value of [release && release.name, release && release.tag_name]) {
|
|
const match = String(value || '').match(/(?:^|[^\d])v?(\d+\.\d+\.\d+)(?=$|[^\d.])/i);
|
|
if (match) return match[1];
|
|
}
|
|
return '';
|
|
}
|
|
|
|
function pickSetupAsset(assets, remoteVersion = '') {
|
|
if (!Array.isArray(assets)) return null;
|
|
const candidates = assets.filter(asset => {
|
|
const name = String(asset?.name || '');
|
|
return /setup/i.test(name) && /\.exe$/i.test(name) && (!remoteVersion || name.includes(remoteVersion));
|
|
});
|
|
return candidates.length === 1 ? candidates[0] : null;
|
|
}
|
|
|
|
function findLatestYml(assets) {
|
|
if (!Array.isArray(assets)) return null;
|
|
return assets.find(a => /^latest\.yml$/i.test(a.name)) || null;
|
|
}
|
|
|
|
function cacheBustedUrl(url) {
|
|
const parsed = new URL(url);
|
|
parsed.searchParams.set('_mhu_update', crypto.randomUUID());
|
|
return parsed.toString();
|
|
}
|
|
|
|
async function fetchJson(url, signal, options = {}) {
|
|
const controller = new AbortController();
|
|
const timeout = setTimeout(() => controller.abort(), CHECK_TIMEOUT);
|
|
const onAbort = () => controller.abort();
|
|
const forceRefresh = options.forceRefresh === true;
|
|
const fetchImpl = options.fetchImpl || fetch;
|
|
if (signal) signal.addEventListener('abort', onAbort);
|
|
|
|
try {
|
|
const res = await fetchImpl(forceRefresh ? cacheBustedUrl(url) : url, {
|
|
method: 'GET',
|
|
signal: controller.signal,
|
|
redirect: 'follow',
|
|
...(forceRefresh ? {
|
|
cache: 'no-store',
|
|
headers: {
|
|
'Cache-Control': 'no-cache, no-store',
|
|
Pragma: 'no-cache'
|
|
}
|
|
} : {})
|
|
});
|
|
const text = await res.text();
|
|
try {
|
|
return JSON.parse(text);
|
|
} catch {
|
|
throw new Error(`Update-Server Antwort war kein JSON (HTTP ${res.status}): ${text.slice(0, 200)}`);
|
|
}
|
|
} finally {
|
|
clearTimeout(timeout);
|
|
if (signal) signal.removeEventListener('abort', onAbort);
|
|
}
|
|
}
|
|
|
|
async function fetchGithubReleaseNotes(remoteVersion, fallback = '', fetchImpl = fetch) {
|
|
const version = String(remoteVersion || '').replace(/^v/i, '').trim();
|
|
if (!/^\d+\.\d+\.\d+$/.test(version)) return String(fallback || '');
|
|
const controller = new AbortController();
|
|
const timeout = setTimeout(() => controller.abort(), CHECK_TIMEOUT);
|
|
try {
|
|
const response = await fetchImpl(`${GITHUB_RELEASE_URL}/v${version}`, {
|
|
method: 'GET',
|
|
redirect: 'follow',
|
|
signal: controller.signal,
|
|
headers: {
|
|
Accept: 'application/vnd.github+json',
|
|
'X-GitHub-Api-Version': '2022-11-28',
|
|
'User-Agent': 'Multi-Hoster-Upload'
|
|
}
|
|
});
|
|
if (!response.ok) return String(fallback || '');
|
|
const release = await response.json();
|
|
const notes = typeof release?.body === 'string' ? release.body.trim() : '';
|
|
return notes || String(fallback || '');
|
|
} catch {
|
|
return String(fallback || '');
|
|
} finally {
|
|
clearTimeout(timeout);
|
|
}
|
|
}
|
|
|
|
async function checkForUpdate(options = {}) {
|
|
const forceRefresh = options.forceRefresh === true;
|
|
const fetchImpl = options.fetchImpl || fetch;
|
|
if (!forceRefresh && cachedCheck && (Date.now() - cachedCheckTs) < CACHE_TTL) {
|
|
return cachedCheck;
|
|
}
|
|
|
|
const releases = await fetchJson(API_URL, undefined, { forceRefresh, fetchImpl });
|
|
|
|
if (!Array.isArray(releases) || releases.length === 0) {
|
|
return { available: false };
|
|
}
|
|
|
|
const release = releases[0];
|
|
const remoteVersion = resolveReleaseVersion(release);
|
|
const transportTag = release.tag_name || '';
|
|
const currentVersion = getCurrentVersion();
|
|
|
|
if (!isNewer(remoteVersion, currentVersion)) {
|
|
cachedCheck = { available: false, currentVersion, remoteVersion, transportTag };
|
|
cachedCheckTs = Date.now();
|
|
return cachedCheck;
|
|
}
|
|
|
|
const setupAsset = pickSetupAsset(release.assets, remoteVersion);
|
|
const latestYml = findLatestYml(release.assets);
|
|
|
|
if (!setupAsset) {
|
|
return { available: false, reason: 'Kein Setup-Asset im Release gefunden' };
|
|
}
|
|
|
|
const releaseNotes = await fetchGithubReleaseNotes(remoteVersion, release.body || '', fetchImpl);
|
|
cachedCheck = {
|
|
available: true,
|
|
currentVersion,
|
|
remoteVersion,
|
|
transportTag,
|
|
publishedAt: release.published_at || null,
|
|
releaseUrl: release.html_url,
|
|
assetUrl: setupAsset.browser_download_url,
|
|
assetSize: setupAsset.size,
|
|
assetName: setupAsset.name,
|
|
latestYmlUrl: latestYml ? latestYml.browser_download_url : null,
|
|
releaseNotes
|
|
};
|
|
cachedCheckTs = Date.now();
|
|
return cachedCheck;
|
|
}
|
|
|
|
async function parseLatestYml(url, expected = {}, fetchImpl = fetch) {
|
|
if (!url) throw new Error('Prüfsummen-Metadaten fehlen');
|
|
try {
|
|
const res = await fetchImpl(url, { redirect: 'follow' });
|
|
if (!res.ok) throw new Error(`Prüfsummen-Metadaten konnten nicht geladen werden: HTTP ${res.status}`);
|
|
const text = await res.text();
|
|
const version = text.match(/^version:\s*([^\r\n]+)$/m)?.[1]?.trim() || '';
|
|
const assetPath = text.match(/^path:\s*([^\r\n]+)$/m)?.[1]?.trim() || '';
|
|
const sha512 = text.match(/^sha512:\s*([A-Za-z0-9+/=]+)$/m)?.[1] || '';
|
|
const sizeText = text.match(/^\s*size:\s*(\d+)\s*$/m)?.[1] || '';
|
|
const size = Number(sizeText);
|
|
if (!version || !assetPath || !sha512 || !Number.isSafeInteger(size) || size <= 0) {
|
|
throw new Error('Prüfsummen-Metadaten sind unvollständig');
|
|
}
|
|
const decodedSha = Buffer.from(sha512, 'base64');
|
|
if (decodedSha.length !== 64 || decodedSha.toString('base64') !== sha512) {
|
|
throw new Error('Prüfsummen-Metadaten enthalten keine gültige SHA-512-Prüfsumme');
|
|
}
|
|
if (expected.version && version !== expected.version) {
|
|
throw new Error('Prüfsummen-Metadaten gehören zu einer anderen Version');
|
|
}
|
|
if (expected.assetName && path.basename(assetPath) !== path.basename(expected.assetName)) {
|
|
throw new Error('Prüfsummen-Metadaten gehören nicht zum ausgewählten Installer');
|
|
}
|
|
if (expected.assetSize && size !== Number(expected.assetSize)) {
|
|
throw new Error('Prüfsummen-Metadaten enthalten eine abweichende Dateigröße');
|
|
}
|
|
return { version, path: assetPath, size, sha512 };
|
|
} catch (error) {
|
|
if (error && /Prüfsummen-Metadaten/.test(error.message)) throw error;
|
|
throw new Error(`Prüfsummen-Metadaten konnten nicht geladen werden: ${error.message}`);
|
|
}
|
|
}
|
|
|
|
async function prepareUpdate(onProgress, options = {}) {
|
|
if (activeAbort) activeAbort.abort();
|
|
const controller = new AbortController();
|
|
activeAbort = controller;
|
|
const signal = controller.signal;
|
|
const fetchImpl = options.fetchImpl || fetch;
|
|
const now = typeof options.now === 'function' ? options.now : Date.now;
|
|
let stagedInstallerPath = '';
|
|
let downloadDirectory = '';
|
|
|
|
try {
|
|
// Stage: starting
|
|
if (onProgress) onProgress({ stage: 'starting', percent: 0 });
|
|
|
|
let check = options.checkResult || null;
|
|
if (!check || !check.available) {
|
|
check = await checkForUpdate({ forceRefresh: true, fetchImpl });
|
|
}
|
|
if (!check || !check.available) {
|
|
throw new Error('Kein Update verfügbar');
|
|
}
|
|
if (!check.assetUrl || !check.assetName) {
|
|
throw new Error('Update-Asset unvollständig (URL oder Name fehlt)');
|
|
}
|
|
if (!check.latestYmlUrl) {
|
|
throw new Error('Prüfsummen-Metadaten fehlen');
|
|
}
|
|
const manifest = await parseLatestYml(check.latestYmlUrl, {
|
|
version: check.remoteVersion,
|
|
assetName: check.assetName,
|
|
assetSize: check.assetSize
|
|
}, fetchImpl);
|
|
const expectedSha = manifest.sha512;
|
|
|
|
// Stage: downloading
|
|
const tmpDir = options.tempDir || app.getPath('temp');
|
|
downloadDirectory = await fs.promises.mkdtemp(path.join(tmpDir, 'mhu-update-'));
|
|
const installerPath = path.join(downloadDirectory, path.basename(check.assetName));
|
|
stagedInstallerPath = installerPath;
|
|
|
|
let actualSha;
|
|
let firstBytes;
|
|
for (let attempt = 1; attempt <= 3; attempt++) {
|
|
signal.throwIfAborted();
|
|
const downloadController = new AbortController();
|
|
const onAbort = () => downloadController.abort();
|
|
signal.addEventListener('abort', onAbort, { once: true });
|
|
let reader;
|
|
let stallTimer;
|
|
let timedOut = false;
|
|
const resetDeadline = () => {
|
|
clearTimeout(stallTimer);
|
|
stallTimer = setTimeout(() => {
|
|
timedOut = true;
|
|
downloadController.abort();
|
|
}, options.downloadStallMs ?? 45000);
|
|
};
|
|
let retry = false;
|
|
try {
|
|
resetDeadline();
|
|
const res = await fetchImpl(check.assetUrl, {
|
|
method: 'GET', signal: downloadController.signal, redirect: 'follow',
|
|
cache: 'no-store', headers: { 'Cache-Control': 'no-cache', 'Accept-Encoding': 'identity' }
|
|
});
|
|
if (!res.ok) {
|
|
const error = new Error(`Download fehlgeschlagen: HTTP ${res.status}`);
|
|
error.retryable = [408, 429, 500, 502, 503, 504].includes(res.status);
|
|
throw error;
|
|
}
|
|
reader = res.body.getReader();
|
|
let downloadedBytes = 0;
|
|
let lastReportedPercent = -1;
|
|
const downloadStartedAt = now();
|
|
const output = await fs.promises.open(installerPath, 'w', 0o600);
|
|
const hash = crypto.createHash('sha512');
|
|
firstBytes = Buffer.alloc(0);
|
|
try {
|
|
if (attempt > 1 && onProgress) onProgress({ stage: 'downloading', percent: 0, bytesDownloaded: 0, bytesTotal: manifest.size, bytesPerSecond: 0, etaSeconds: null, attempt });
|
|
while (true) {
|
|
signal.throwIfAborted();
|
|
resetDeadline();
|
|
const { done, value } = await reader.read();
|
|
clearTimeout(stallTimer);
|
|
if (done) break;
|
|
downloadedBytes += value.length;
|
|
if (downloadedBytes > manifest.size) throw new Error('Heruntergeladene Datei hat eine abweichende Größe');
|
|
if (firstBytes.length < 2) firstBytes = Buffer.concat([firstBytes, Buffer.from(value).subarray(0, 2 - firstBytes.length)]);
|
|
hash.update(value);
|
|
await output.writeFile(value);
|
|
const percent = Math.floor((downloadedBytes / manifest.size) * 100);
|
|
if (onProgress && percent !== lastReportedPercent) {
|
|
const elapsedMs = Math.max(1, now() - downloadStartedAt);
|
|
const bytesPerSecond = Math.round((downloadedBytes * 1000) / elapsedMs);
|
|
const etaSeconds = bytesPerSecond > 0 ? Math.ceil(Math.max(0, manifest.size - downloadedBytes) / bytesPerSecond) : null;
|
|
lastReportedPercent = percent;
|
|
onProgress({ stage: 'downloading', percent, bytesDownloaded: downloadedBytes, bytesTotal: manifest.size, bytesPerSecond, etaSeconds, attempt });
|
|
await new Promise(resolve => setImmediate(resolve));
|
|
}
|
|
}
|
|
signal.throwIfAborted();
|
|
if (downloadedBytes !== manifest.size) {
|
|
const error = new Error('Heruntergeladene Datei ist unvollständig');
|
|
error.retryable = true;
|
|
throw error;
|
|
}
|
|
await output.sync();
|
|
actualSha = hash.digest('base64');
|
|
} finally { await output.close(); }
|
|
} catch (error) {
|
|
signal.throwIfAborted();
|
|
retry = timedOut || error.retryable === true || ['UND_ERR_SOCKET', 'ECONNRESET', 'ETIMEDOUT', 'EPIPE', 'UND_ERR_CONNECT_TIMEOUT', 'UND_ERR_BODY_TIMEOUT'].includes(error.cause?.code || error.code) || /^(terminated|fetch failed)$/i.test(error.message);
|
|
if (!retry) throw error;
|
|
if (attempt === 3) throw new Error('Update-Download nach 3 Versuchen unterbrochen. Bitte Verbindung prüfen oder den Installer manuell herunterladen.', { cause: error });
|
|
} finally {
|
|
clearTimeout(stallTimer);
|
|
signal.removeEventListener('abort', onAbort);
|
|
downloadController.abort();
|
|
if (reader) {
|
|
try { reader.releaseLock?.(); } catch {}
|
|
}
|
|
}
|
|
if (!retry) break;
|
|
await delay(options.retryDelayMs ?? attempt * 1000, undefined, { signal });
|
|
}
|
|
signal.throwIfAborted();
|
|
|
|
// Stage: verifying
|
|
if (onProgress) onProgress({ stage: 'verifying', percent: 0 });
|
|
|
|
if (manifest.size < 128 * 1024 || firstBytes[0] !== 0x4d || firstBytes[1] !== 0x5a) {
|
|
throw new Error('Heruntergeladene Datei ist keine gültige EXE');
|
|
}
|
|
|
|
if (actualSha !== expectedSha) {
|
|
const actualHex = Buffer.from(actualSha, 'base64').toString('hex');
|
|
if (actualHex !== expectedSha.toLowerCase()) {
|
|
throw new Error('SHA-512 Prüfung fehlgeschlagen');
|
|
}
|
|
}
|
|
|
|
const prepared = {
|
|
installerPath,
|
|
sha512: actualSha,
|
|
size: manifest.size,
|
|
sha512Verified: true,
|
|
assetName: check.assetName,
|
|
remoteVersion: check.remoteVersion || '',
|
|
transportTag: check.transportTag || ''
|
|
};
|
|
await verifyPreparedUpdate(prepared);
|
|
stagedInstallerPath = '';
|
|
if (onProgress) onProgress({ stage: 'prepared', percent: 100 });
|
|
return prepared;
|
|
|
|
} catch (err) {
|
|
const failure = signal.aborted ? new Error('Update abgebrochen') : err;
|
|
if (stagedInstallerPath) await fs.promises.unlink(stagedInstallerPath).catch(() => {});
|
|
if (downloadDirectory) await fs.promises.rmdir(downloadDirectory).catch(() => {});
|
|
if (onProgress) onProgress({ stage: signal.aborted ? 'aborted' : 'error', error: failure.message });
|
|
throw failure;
|
|
} finally {
|
|
if (activeAbort === controller) activeAbort = null;
|
|
}
|
|
}
|
|
|
|
async function verifyPreparedUpdate(prepared) {
|
|
if (!prepared?.sha512Verified || !prepared.sha512 || !Number.isSafeInteger(prepared.size)) throw new Error('Update-Prüfsumme fehlt');
|
|
const stat = await fs.promises.lstat(prepared.installerPath);
|
|
if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1 || stat.size !== prepared.size) throw new Error('Update-Datei wurde verändert');
|
|
const handle = await fs.promises.open(prepared.installerPath, 'r');
|
|
try {
|
|
const hash = crypto.createHash('sha512');
|
|
const before = await handle.stat();
|
|
if (before.ino !== stat.ino || before.dev !== stat.dev || before.size !== stat.size) throw new Error('Update-Datei wurde ausgetauscht');
|
|
for await (const chunk of handle.createReadStream({ autoClose: false })) hash.update(chunk);
|
|
const after = await handle.stat();
|
|
if (after.size !== before.size || after.mtimeMs !== before.mtimeMs || after.ctimeMs !== before.ctimeMs || hash.digest('base64') !== prepared.sha512) throw new Error('SHA-512 Prüfung fehlgeschlagen');
|
|
} finally { await handle.close(); }
|
|
return true;
|
|
}
|
|
|
|
async function launchVerifiedUpdate(prepared, directory, options = {}) {
|
|
await verifyPreparedUpdate(prepared);
|
|
const spawn = options.spawnImpl || require('node:child_process').spawn;
|
|
const child = spawn(prepared.installerPath, ['/S', '--updated', '--force-run', `/D=${directory}`], { detached: true, windowsHide: true, stdio: 'ignore' });
|
|
await new Promise((resolve, reject) => { child.once('error', reject); child.once('spawn', resolve); });
|
|
child.unref();
|
|
launchedInstallerPaths.add(path.resolve(prepared.installerPath).toLowerCase());
|
|
return true;
|
|
}
|
|
|
|
function launchPreparedUpdate(prepared, options = {}) {
|
|
const installerPath = prepared && typeof prepared.installerPath === 'string' ? prepared.installerPath : '';
|
|
if (!installerPath) throw new Error('Vorbereitetes Update ist unvollständig');
|
|
const key = path.resolve(installerPath).toLowerCase();
|
|
if (launchedInstallerPaths.has(key)) return false;
|
|
const spawnImpl = options.spawnImpl || require('child_process').spawn;
|
|
launchedInstallerPaths.add(key);
|
|
try {
|
|
spawnImpl(installerPath, ['/S', '--updated', '--force-run'], {
|
|
detached: true,
|
|
windowsHide: true,
|
|
stdio: 'ignore'
|
|
}).unref();
|
|
return true;
|
|
} catch (error) {
|
|
launchedInstallerPaths.delete(key);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
function abortUpdate() {
|
|
if (!activeAbort) return false;
|
|
activeAbort.abort();
|
|
return true;
|
|
}
|
|
|
|
module.exports = { checkForUpdate, fetchGithubReleaseNotes, prepareUpdate, verifyPreparedUpdate, launchVerifiedUpdate, launchPreparedUpdate, abortUpdate, isNewer, resolveReleaseVersion, pickSetupAsset, parseLatestYml, createUpdateAnnouncementState };
|