'; }
+ return `${k}=${sv}`;
+ })
+ .join(' ');
+ rotLog(`[${event}] ${pairs}`, ts);
+ if (entry.jobId) {
+ _appendJobLog(entry.jobId, { ts: ts || Date.now(), kind: 'rot', event, ...rest });
+ }
+ if (ROT_LOG_RENDERER_EVENTS.has(event)) {
+ safeSend('account-rotation-log', entry);
+ }
+ } catch (e) { debugLog(`rot-log listener error: ${e && e.message}`); }
+ });
+
+ // Capture the manager identity at listener-registration time so the post-
+ // batch null-out can compare against IT — not against whatever the global
+ // happens to point at after an `await`. Without this, a renderer that
+ // fires start-upload while we're still awaiting appendHistory would
+ // create a fresh manager which the trailing `uploadManager = null` then
+ // orphans (cancel/addJobs see null, the new batch keeps running invisibly).
+ uploadManager.on('batch-done', async (summary) => {
+ debugLog(`batch-done: total=${summary.total} ok=${summary.succeeded} fail=${summary.failed}`);
+ logMarker('BATCH END', { total: summary.total, ok: summary.succeeded, fail: summary.failed });
+ logMemorySnapshot('batch-done');
+ const _batchDurationSec = _thisManager && _thisManager.startTime
+ ? Math.round((Date.now() - _thisManager.startTime) / 1000)
+ : 0;
+ try { await configStore.appendHistory(summary); } catch (err) {
+ debugLog(`appendHistory failed: ${err.message}`);
+ }
+ if (_progressFlushTimer) {
+ clearTimeout(_progressFlushTimer);
+ _progressFlushTimer = null;
+ }
+ const finalProgressBatch = _progressTerminalQueue.splice(0);
+ for (const value of _progressByJob.values()) finalProgressBatch.push(value);
+ _progressByJob.clear();
+ if (finalProgressBatch.length) safeSend('upload-progress-batch', finalProgressBatch);
+ safeSend('upload-batch-done', summary);
+ _producerTracker.finish();
+
+ const fullyAborted = isAllAborted(summary);
+ if (isAutoRetry) {
+ debugLog('webhook: skipped — auto-retry round (initial batch already notified)');
+ } else if (fullyAborted) {
+ debugLog('webhook: skipped — batch fully aborted/cancelled');
+ } else {
+ await sendBatchWebhook(summary, _batchDurationSec, { aborted: fullyAborted });
+ }
+
+ // Shutdown after finish
+ handleShutdownAfterFinish();
+ if (uploadManager === _thisManager) { uploadManager = null; globalThis._mhuUploadManagerRef = null; }
+ else debugLog('batch-done: skipping uploadManager null-out — a newer manager replaced this one mid-await');
+ });
+
+ // Defer startBatch to next tick so the IPC response is sent first.
+ // This ensures webContents.send() calls from upload events
+ // are not interleaved with the handle() response.
+ process.nextTick(() => {
+ if (uploadManager !== _thisManager) {
+ debugLog('nextTick: uploadManager was replaced before startBatch');
+ _producerTracker.finish();
+ return;
+ }
+ if (closeFlushRequested) {
+ try { _thisManager.cancel(); } catch {}
+ if (uploadManager === _thisManager) { uploadManager = null; globalThis._mhuUploadManagerRef = null; }
+ _producerTracker.finish();
+ return;
+ }
+ debugLog(`nextTick: calling startBatch now (priming ${_sessionFailedAccounts.size} failed accounts, ${_sessionAccountOverrides.size} overrides from session)`);
+ _thisManager.startBatch(tasks, {
+ primeFailedAccounts: Array.from(_sessionFailedAccounts.keys()),
+ primeOverrides: Array.from(_sessionAccountOverrides.entries())
+ }).catch((err) => {
+ debugLog(`startBatch REJECTED: ${err && err.stack ? err.stack : err}`);
+ const errorSummary = {
+ id: 'error',
+ timestamp: new Date().toISOString(),
+ total: tasks.length,
+ succeeded: 0,
+ failed: tasks.length,
+ files: [],
+ error: err ? err.message : 'Unbekannter Fehler'
+ };
+ safeSend('upload-batch-done', errorSummary);
+ _producerTracker.finish();
+ if (!isAutoRetry) sendBatchWebhook(errorSummary, 0);
+ if (uploadManager === _thisManager) { uploadManager = null; globalThis._mhuUploadManagerRef = null; }
+ });
+ });
+
+ logMemorySnapshot('batch-start');
+ debugLog(`start-upload returning started=true (startBatch deferred to nextTick)`);
+ return { started: true, taskCount: tasks.length, skippedJobs };
+});
+
+// Logged at batch boundaries so we can spot memory growth between batches
+// across long sessions (main process side only — the renderer's live view
+// still uses DevTools for profiling). Non-invasive: single line per boundary.
+function logMemorySnapshot(label) {
+ try {
+ const m = process.memoryUsage();
+ const mb = (n) => (n / 1024 / 1024).toFixed(1);
+ debugLog(`memory[${label}]: rss=${mb(m.rss)}MB heap=${mb(m.heapUsed)}/${mb(m.heapTotal)}MB external=${mb(m.external)}MB arrayBuffers=${mb(m.arrayBuffers)}MB`);
+ } catch {}
+}
+
+ipcMain.handle('cancel-upload', () => {
+ if (uploadManager) {
+ uploadManager.cancel();
+ }
+ return true;
+});
+
+ipcMain.handle('cancel-selected-jobs', (_event, jobIds) => {
+ if (uploadManager) {
+ uploadManager.cancelJobs(Array.isArray(jobIds) ? jobIds : []);
+ }
+ return true;
+});
+
+ipcMain.handle('add-jobs-to-batch', (_event, payload) => {
+ if (closeFlushRequested) return { error: 'Die Anwendung wird gerade beendet' };
+ if (!uploadManager || !uploadManager.running) {
+ return { error: 'Kein Upload aktiv' };
+ }
+ const config = configStore.load();
+ const jobs = payload && Array.isArray(payload.jobs) ? payload.jobs : [];
+ const pick = makeAccountPicker(config);
+ const tasks = buildUploadTasksFromJobs(config, jobs, pick);
+ persistRotation(pick);
+ const taskJobIds = new Set(tasks.map(t => t.jobId).filter(Boolean));
+ const skippedJobs = jobs
+ .filter(j => j && j.id && !taskJobIds.has(j.id))
+ .map(j => ({ jobId: j.id, hoster: j.hoster, reason: 'Kein gültiger Account für diesen Hoster' }));
+
+ if (tasks.length === 0) {
+ debugLog(`add-jobs-to-batch: 0 tasks built (${skippedJobs.length} skipped: no account)`);
+ return { added: 0, skippedJobs, alreadyInBatchJobIds: [] };
+ }
+
+ const addResult = uploadManager.addJobs(tasks);
+ const added = typeof addResult === 'number' ? addResult : (addResult && addResult.added) || 0;
+ const alreadyInBatchJobIds = (addResult && Array.isArray(addResult.alreadyInBatchJobIds))
+ ? addResult.alreadyInBatchJobIds
+ : [];
+
+ debugLog(
+ `add-jobs-to-batch: ${added} of ${tasks.length} tasks added (${alreadyInBatchJobIds.length} already in batch, ${skippedJobs.length} skipped)`
+ );
+ return { added, skippedJobs, alreadyInBatchJobIds };
+});
+
+ipcMain.handle('finish-after-active', () => {
+ if (uploadManager) {
+ uploadManager.finishAfterActive();
+ }
+ return true;
+});
+
+ipcMain.handle('get-session-failed-accounts', () => {
+ return Array.from(_sessionFailedAccounts.keys());
+});
+
+ipcMain.handle('reset-session-failed-account', (_event, payload) => {
+ if (!payload || typeof payload !== 'object') return { ok: false };
+ const { hoster, accountId } = payload;
+ if (!hoster || !accountId) return { ok: false };
+ const key = `${hoster}:${accountId}`;
+ const removed = _sessionFailedAccounts.delete(key);
+ if (uploadManager && typeof uploadManager.clearFailedAccount === 'function') {
+ try { uploadManager.clearFailedAccount(hoster, accountId); } catch {}
+ }
+ rotLog(`session-failed: manual reset ${key} (was set: ${removed})`);
+ return { ok: true, removed };
+});
+
+ipcMain.handle('reset-all-session-failed-accounts', () => {
+ const count = _sessionFailedAccounts.size;
+ _sessionFailedAccounts.clear();
+ if (uploadManager && typeof uploadManager.clearAllFailedAccounts === 'function') {
+ try { uploadManager.clearAllFailedAccounts(); } catch {}
+ }
+ rotLog(`session-failed: cleared all (${count})`);
+ return { ok: true, count };
+});
+
+ipcMain.handle('get-job-log', (_event, jobId) => {
+ if (!jobId || typeof jobId !== 'string') return [];
+ const arr = _jobLogCollector.get(jobId);
+ return Array.isArray(arr) ? arr.slice() : [];
+});
+
+ipcMain.handle('get-log-paths', () => {
+ return getAllLogPaths();
+});
+
+ipcMain.handle('get-app-info', () => {
+ return {
+ name: app.getName(),
+ version: app.getVersion(),
+ electron: process.versions.electron,
+ node: process.versions.node,
+ chrome: process.versions.chrome,
+ platform: process.platform,
+ arch: process.arch,
+ osRelease: require('os').release(),
+ pid: process.pid,
+ isPackaged: app.isPackaged,
+ logVerbose: _logVerbose
+ };
+});
+
+ipcMain.handle('reveal-log-file', async (_event, target) => {
+ const { shell } = require('electron');
+ const paths = getAllLogPaths();
+ const file = (target && typeof target === 'string' && paths[target]) || null;
+ try {
+ if (file && fs.existsSync(file)) {
+ shell.showItemInFolder(file);
+ return { ok: true, path: file };
+ }
+ const dir = paths.logDir;
+ if (dir) {
+ fs.mkdirSync(dir, { recursive: true });
+ shell.openPath(dir);
+ return { ok: true, path: dir };
+ }
+ return { ok: false, error: 'Kein Log-Pfad gefunden' };
+ } catch (err) {
+ return { ok: false, error: err.message };
+ }
+});
+
+ipcMain.handle('test-webhook', async (_event, payload) => {
+ const target = (typeof payload === 'string' ? payload : (payload && payload.url) || '').trim();
+ const mention = (payload && typeof payload === 'object' && payload.mention) || '';
+ if (!target || !/^https?:\/\//i.test(target)) return { ok: false, error: 'Ungültige URL (muss mit http(s):// beginnen)' };
+ try {
+ const req = buildWebhookRequest(target, {
+ total: 3, succeeded: 2, failed: 1,
+ files: [{ name: 'test.mkv', results: [
+ { hoster: 'voe.sx', status: 'done' },
+ { hoster: 'byse.sx', status: 'done' },
+ { hoster: 'doodstream.com', status: 'error', error: 'Testfehler' }
+ ] }]
+ }, {
+ durationSec: 754,
+ appVersion: app.getVersion(),
+ machineName: require('os').hostname(),
+ mention,
+ timestamp: new Date().toISOString()
+ });
+ const res = await fetch(req.url, {
+ method: req.method, headers: req.headers, body: req.body,
+ signal: AbortSignal.timeout(10_000)
+ });
+ return { ok: res.status >= 200 && res.status < 300, status: res.status };
+ } catch (err) {
+ return { ok: false, error: err && err.message ? err.message : String(err) };
+ }
+});
+
+ipcMain.handle('set-log-verbose', (_event, enabled) => {
+ setLogVerbose(enabled);
+ logMarker('VERBOSE TOGGLE', { enabled: _logVerbose });
+ return { ok: true, verbose: _logVerbose };
+});
+
+ipcMain.handle('create-support-bundle', async () => {
+ const { dialog } = require('electron');
+ try {
+ if (_debugLogBuffer.length) {
+ try { fs.appendFileSync(getDebugLogPath(), _debugLogBuffer.join(''), 'utf-8'); _debugLogBuffer.length = 0; } catch {}
+ }
+ const stamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+ const defaultName = `multi-hoster-support-${stamp}.txt`;
+ const desktop = (() => { try { return app.getPath('desktop'); } catch { return app.getPath('userData'); } })();
+ const res = await dialog.showSaveDialog(mainWindow || undefined, {
+ title: 'Diagnose-Paket speichern',
+ defaultPath: path.join(desktop, defaultName),
+ filters: [{ name: 'Text', extensions: ['txt'] }]
+ });
+ if (res.canceled || !res.filePath) return { ok: false, canceled: true };
+ const paths = getAllLogPaths();
+ const cfg = configStore.load();
+ const text = buildSupportBundleText({
+ header: {
+ App: app.getName(),
+ Version: app.getVersion(),
+ Electron: process.versions.electron,
+ Node: process.versions.node,
+ Chrome: process.versions.chrome,
+ Platform: process.platform,
+ Arch: process.arch,
+ OS: `${require('os').type()} ${require('os').release()}`,
+ Packaged: app.isPackaged,
+ Verbose: _logVerbose,
+ PID: process.pid,
+ CreatedAt: new Date().toISOString()
+ },
+ sanitizedConfig: sanitizeConfig(cfg),
+ files: [
+ { label: 'debug.log (last 5 MB)', path: paths.debug, maxBytes: 5 * 1024 * 1024 },
+ { label: 'account-rotation.log (last 2 MB)', path: paths.accountRotation, maxBytes: 2 * 1024 * 1024 },
+ { label: 'doodstream-debug.log (last 2 MB)', path: paths.doodstreamDebug, maxBytes: 2 * 1024 * 1024 },
+ { label: 'crash.log', path: path.join(paths.logDir || path.dirname(paths.debug), 'crash.log'), maxBytes: 1 * 1024 * 1024 },
+ { label: 'fileuploader.log (last 1 MB)', path: paths.fileuploader, maxBytes: 1 * 1024 * 1024 }
+ ]
+ });
+ fs.writeFileSync(res.filePath, text, 'utf-8');
+ logMarker('SUPPORT BUNDLE', { path: res.filePath, bytes: text.length });
+ return { ok: true, path: res.filePath, bytes: text.length };
+ } catch (err) {
+ debugLog(`create-support-bundle failed: ${err.message}`);
+ return { ok: false, error: err.message };
+ }
+});
+
+ipcMain.handle('open-log-folder', async () => {
+ // Reveal the active log file (or its directory) in the OS file manager.
+ // Prefers the configured log path, then the rotation log, then just the
+ // parent dir.
+ const { shell } = require('electron');
+ const primary = getLogFilePath();
+ if (fs.existsSync(primary)) { shell.showItemInFolder(primary); return { ok: true, path: primary }; }
+ const rot = getRotLogPath();
+ if (fs.existsSync(rot)) { shell.showItemInFolder(rot); return { ok: true, path: rot }; }
+ try {
+ const dir = path.dirname(primary);
+ fs.mkdirSync(dir, { recursive: true });
+ shell.openPath(dir);
+ return { ok: true, path: dir };
+ } catch (err) {
+ return { ok: false, error: err.message };
+ }
+});
+
+ipcMain.handle('clear-history', async () => {
+ assertConfigWriteAllowed();
+ await configStore.clearHistory();
+ return true;
+});
+
+async function syncImportedRuntime(config) {
+ const warnings = [];
+ try {
+ setLogVerbose(!!config.globalSettings.logVerbose);
+ if (uploadManager) {
+ uploadManager.updateSettings(config.hosterSettings, config.globalSettings);
+ uploadManager.replaceAccountPools(buildAccountPools(config));
+ }
+ if (mainWindow && !mainWindow.isDestroyed()) mainWindow.setAlwaysOnTop(!!config.globalSettings.alwaysOnTop);
+ } catch (error) {
+ debugLog(`backup runtime settings failed: ${error.message}`);
+ warnings.push('allgemeine Laufzeiteinstellungen');
+ }
+ try {
+ folderMonitor.stop();
+ const folderSettings = config.globalSettings.folderMonitor;
+ if (folderSettings && folderSettings.enabled && folderSettings.folderPath) startFolderMonitor(folderSettings);
+ } catch (error) {
+ debugLog(`backup folder monitor sync failed: ${error.message}`);
+ warnings.push('Ordnerüberwachung');
+ }
+ try {
+ const remoteSettings = config.globalSettings.remote;
+ if (remoteSettings && remoteSettings.enabled) await startRemoteServer();
+ else if (remoteServer) {
+ remoteServer.stop();
+ remoteServer = null;
+ destroyCaptureWindow();
+ }
+ } catch (error) {
+ debugLog(`backup remote sync failed: ${error.message}`);
+ warnings.push('Remote-Steuerung');
+ }
+ try {
+ const diagnostics = config.globalSettings.diagnostics;
+ if (diagnostics && diagnostics.enabled) await startDiagnosticAgent();
+ else stopDiagnosticAgent();
+ } catch (error) {
+ debugLog(`backup diagnostics sync failed: ${error.message}`);
+ warnings.push('Diagnose');
+ }
+ try {
+ if (config.globalSettings.showDropTarget) createDropTargetWindow();
+ else destroyDropTargetWindow();
+ } catch (error) {
+ debugLog(`backup drop target sync failed: ${error.message}`);
+ warnings.push('Drop-Target');
+ }
+ return warnings;
+}
+
+async function applyImportedSettings(imported) {
+ settingsImportGate.begin();
+ try {
+ await waitForConfigStoreWrites();
+ const prepared = prepareImportedSettings(imported);
+ const ts = new Date().toISOString().replace(/[:.]/g, '-');
+ const preImportPath = configStore.filePath.replace('.json', `.pre-import-${ts}.json`);
+ try { fs.copyFileSync(configStore.filePath, preImportPath); } catch {}
+ await configStore.replaceSettings(prepared);
+ _rotationCursors = {};
+ _sessionFailedAccounts.clear();
+ _sessionAccountOverrides.clear();
+ _invalidateLogSettings();
+ const config = configStore.load();
+ const warnings = await syncImportedRuntime(config);
+ return { config, warnings };
+ } finally {
+ settingsImportGate.end();
+ }
+}
+
+function readBackupFile(filePath) {
+ const stat = fs.statSync(filePath);
+ if (!stat.isFile() || stat.size > 2 * 1024 * 1024) throw new Error('Backup-Datei ist zu groß oder ungültig');
+ return fs.readFileSync(filePath);
+}
+
+// --- Backup export / import ---
+ipcMain.handle('export-backup', async () => {
+ const _bd = new Date();
+ const _bdate = `${String(_bd.getDate()).padStart(2, '0')}-${String(_bd.getMonth() + 1).padStart(2, '0')}-${_bd.getFullYear()}`;
+ const { canceled, filePath } = await dialog.showSaveDialog(mainWindow, {
+ title: 'Backup exportieren',
+ defaultPath: `${_bdate}-multihoster-backup.mhu`,
+ filters: [
+ { name: 'Multi-Hoster Backup (verschlüsselt)', extensions: ['mhu'] },
+ { name: 'Multi-Hoster Backup (Klartext JSON)', extensions: ['json'] }
+ ]
+ });
+ if (canceled || !filePath) return { ok: false, canceled: true };
+ await waitForConfigStoreWrites();
+ const config = createPortableSettingsSnapshot(configStore.load());
+ if (filePath.toLowerCase().endsWith('.json')) {
+ fs.writeFileSync(filePath, JSON.stringify(config, null, 2), 'utf-8');
+ } else {
+ const encrypted = backupCrypto.encrypt(config);
+ fs.writeFileSync(filePath, encrypted);
+ }
+ return { ok: true, path: filePath };
+});
+
+ipcMain.handle('import-backup', async (_event, legacyPassword) => {
+ let buffer;
+ let sourcePath = _lastImportPath;
+ if (legacyPassword && sourcePath) {
+ buffer = readBackupFile(sourcePath);
+ } else {
+ const { canceled, filePaths } = await dialog.showOpenDialog(mainWindow, {
+ title: 'Backup importieren',
+ filters: [
+ { name: 'Multi-Hoster Backup', extensions: ['mhu', 'json'] },
+ { name: 'Verschlüsselt (.mhu)', extensions: ['mhu'] },
+ { name: 'Klartext (.json)', extensions: ['json'] }
+ ],
+ properties: ['openFile']
+ });
+ if (canceled || !filePaths.length) return { ok: false, canceled: true };
+ sourcePath = filePaths[0];
+ buffer = readBackupFile(sourcePath);
+ _lastImportPath = sourcePath;
+ }
+ let imported;
+ const looksLikeJson = buffer.length >= 1 && (buffer[0] === 0x7B || buffer[0] === 0x20 || buffer[0] === 0x0A || buffer[0] === 0x0D || buffer[0] === 0x09 || buffer[0] === 0xEF);
+ if (looksLikeJson) {
+ try {
+ const text = buffer.toString('utf-8').replace(/^\uFEFF/, '');
+ imported = JSON.parse(text);
+ } catch (err) {
+ _lastImportPath = null;
+ return { ok: false, error: 'Klartext-Backup ist kein gültiges JSON: ' + (err.message || err) };
+ }
+ } else {
+ try {
+ imported = backupCrypto.decrypt(buffer, legacyPassword);
+ } catch (err) {
+ if (err && err.needsPassword) {
+ return { ok: false, needsPassword: true, hint: 'Falls dieses Backup mit der aktuellen Version erzeugt wurde, ist die Datei vermutlich beim Transfer beschädigt worden (z. B. FTP-Text-Modus). Versuch es mit einem Klartext-JSON-Export.' };
+ }
+ _lastImportPath = null;
+ throw err;
+ }
+ }
+ _lastImportPath = null;
+ try {
+ return { ok: true, ...await applyImportedSettings(imported) };
+ } catch (error) {
+ return { ok: false, error: error.message || String(error) };
+ }
+});
+
+ipcMain.handle('online-backup:create', async () => {
+ try {
+ await waitForConfigStoreWrites();
+ const snapshot = createPortableSettingsSnapshot(configStore.load());
+ const created = createOnlineBackup(snapshot, app.getVersion());
+ await uploadOnlineBackup(created.record);
+ return { ok: true, key: created.key };
+ } catch (error) {
+ return { ok: false, error: error.message || String(error) };
+ }
+});
+
+ipcMain.handle('online-backup:restore', async (_event, key) => {
+ try {
+ const normalized = String(key || '').trim();
+ if (normalized.length > 128) throw new Error('Online-Sicherungsschlüssel ist ungültig');
+ const payload = await downloadOnlineBackup(normalized);
+ return { ok: true, ...await applyImportedSettings(payload.settings) };
+ } catch (error) {
+ return { ok: false, error: error.message || String(error) };
+ }
+});
+
+ipcMain.handle('read-own-upload-log', () => {
+ // Read all log files (base + daily logs) and return parsed entries
+ const entries = [];
+ const basePath = getBaseLogFilePath();
+ const dir = path.dirname(basePath);
+ const ext = path.extname(basePath);
+ const name = path.basename(basePath, ext);
+
+ // Collect all matching log files (base + daily variants)
+ const logFiles = [];
+ try {
+ for (const file of fs.readdirSync(dir)) {
+ if (file.startsWith(name) && file.endsWith(ext)) {
+ logFiles.push(path.join(dir, file));
+ }
+ }
+ } catch {}
+ if (logFiles.length === 0 && fs.existsSync(basePath)) {
+ logFiles.push(basePath);
+ }
+
+ for (const logPath of logFiles) {
+ try {
+ const content = fs.readFileSync(logPath, 'utf-8');
+ for (const line of content.split('\n')) {
+ const parsed = parseUploadLogLine(line);
+ if (parsed) entries.push(parsed);
+ }
+ } catch {}
+ }
+ return entries;
+});
+
+ipcMain.handle('import-upload-log', async () => {
+ const { canceled, filePaths } = await dialog.showOpenDialog(mainWindow, {
+ title: 'Upload-Log importieren',
+ filters: [
+ { name: 'Log-Dateien', extensions: ['log', 'txt'] },
+ { name: 'Alle Dateien', extensions: ['*'] }
+ ],
+ properties: ['openFile']
+ });
+ if (canceled || !filePaths.length) return { canceled: true };
+ const content = fs.readFileSync(filePaths[0], 'utf-8');
+ // Parse log format: date|hoster|link||filename|
+ const entries = [];
+ for (const line of content.split('\n')) {
+ const trimmed = line.trim();
+ if (!trimmed || trimmed.startsWith('#')) continue;
+ const parts = trimmed.split('|');
+ if (parts.length >= 5) {
+ const hoster = (parts[1] || '').trim();
+ const fileName = (parts[4] || '').trim();
+ if (hoster && fileName) entries.push({ hoster, fileName });
+ }
+ }
+ return { entries, path: filePaths[0] };
+});
+
+ipcMain.handle('copy-to-clipboard', (_event, text) => {
+ clipboard.writeText(text);
+ return true;
+});
+
+ipcMain.handle('app:check-updates', async () => {
+ try {
+ return await checkForUpdate();
+ } catch (err) {
+ return { available: false, error: err.message };
+ }
+});
+
+ipcMain.handle('app:install-update', async () => {
+ if (updatePreparationPromise || preparedUpdate || updateQuitPending) {
+ return { started: false, error: 'Ein Update wird bereits vorbereitet' };
+ }
+ updatePreparationPromise = (async () => {
+ const prepared = await prepareUpdate((progress) => {
+ safeSend('app:update-progress', progress);
+ });
+ if (!mainWindow || mainWindow.isDestroyed() || mainWindow.webContents.isDestroyed() || !closeHandshakeReady) {
+ throw new Error('Die Anwendung ist noch nicht bereit, das Update sicher zu installieren');
+ }
+ preparedUpdate = prepared;
+ updateQuitPending = true;
+ preparedUpdateLaunchStarted = false;
+ setImmediate(() => app.quit());
+ return { started: true };
+ })();
+ try {
+ return await updatePreparationPromise;
+ } catch (error) {
+ rejectPendingUpdate(error);
+ safeSend('app:update-progress', { stage: 'error', error: error.message });
+ return { started: false, error: error.message };
+ } finally {
+ updatePreparationPromise = null;
+ }
+});
+
+ipcMain.handle('app:abort-update', () => {
+ abortUpdate();
+ rejectPendingUpdate(new Error('Update abgebrochen'));
+ return true;
+});
+
+ipcMain.handle('app:get-version', () => {
+ return app.getVersion();
+});
+
+ipcMain.handle('app:restart', () => {
+ restartAfterClosePreparation = true;
+ app.quit();
+});
+
+ipcMain.handle('app:quit', () => {
+ app.quit();
+});
+
+ipcMain.on('app:close-handshake-ready', (event) => {
+ if (mainWindow && !mainWindow.isDestroyed() && event.sender === mainWindow.webContents) closeHandshakeReady = true;
+});
+
+ipcMain.on('app:close-preparation-started', (event, attempt) => {
+ if (mainWindow && !mainWindow.isDestroyed() && event.sender === mainWindow.webContents && isClosePreparationActive(attempt)) {
+ armCloseFlushTimer(attempt, 3000);
+ }
+});
+
+ipcMain.handle('app:finish-close', async (event, payload = true) => {
+ if (!mainWindow || mainWindow.isDestroyed() || event.sender !== mainWindow.webContents) return false;
+ const attempt = payload && typeof payload === 'object' && Number.isInteger(payload.attempt) ? payload.attempt : null;
+ if (attempt === null) return false;
+ const ready = payload && typeof payload === 'object' ? payload.ready !== false : payload !== false;
+ if (!ready) {
+ if (isClosePreparationActive(attempt)) {
+ clearCloseFlushTimer();
+ return restoreClosePreparation(attempt);
+ }
+ return lastRestoredCloseAttempt === attempt;
+ }
+ if (!isClosePreparationActive(attempt)) return false;
+ clearCloseFlushTimer();
+ let approved = false;
+ try {
+ if (!acquireCloseQuiesce(attempt)) return false;
+ await waitForCloseOperation(waitForConfigStoreWrites(), 1000);
+ if (!isClosePreparationActive(attempt)) return false;
+ if (payload && typeof payload === 'object' && Object.prototype.hasOwnProperty.call(payload, 'pendingQueue')) {
+ await waitForCloseOperation(configStore.savePendingQueue(payload.pendingQueue, { allowDuringQuiesce: true }), 1000);
+ }
+ if (!isClosePreparationActive(attempt)) return false;
+ closeFlushApproved = true;
+ approved = true;
+ setImmediate(() => {
+ app.quit();
+ });
+ return true;
+ } catch {
+ restoreClosePreparation(attempt);
+ return false;
+ } finally {
+ if (!approved) releaseCloseQuiesce(attempt);
+ }
+});
+
+// --- Hoster settings ---
+ipcMain.handle('get-hoster-settings', () => {
+ const config = configStore.load();
+ return config.hosterSettings || {};
+});
+
+ipcMain.handle('save-hoster-settings', async (_event, hosterSettings) => {
+ assertConfigWriteAllowed();
+ await configStore.save({ hosterSettings });
+ if (uploadManager) {
+ try { uploadManager.updateSettings(hosterSettings, null); } catch (error) { debugLog(`hoster settings runtime update failed: ${error.message}`); }
+ }
+ return true;
+});
+
+// --- Global settings ---
+ipcMain.handle('get-global-settings', () => {
+ const config = configStore.load();
+ return config.globalSettings || {};
+});
+
+ipcMain.handle('save-pending-queue', async (_event, pendingQueue) => {
+ await configStore.savePendingQueue(pendingQueue);
+ return true;
+});
+
+ipcMain.handle('save-global-settings', async (_event, globalSettings) => {
+ assertConfigWriteAllowed();
+ await configStore.saveRendererGlobalSettings(globalSettings);
+ globalSettings = configStore.load().globalSettings;
+ _invalidateLogSettings();
+ if (uploadManager) {
+ try { uploadManager.updateSettings(null, globalSettings); } catch (error) { debugLog(`global settings runtime update failed: ${error.message}`); }
+ }
+ return true;
+});
+
+function _sleepSyncMs(ms) {
+ try {
+ Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+ } catch {
+ const end = Date.now() + ms;
+ while (Date.now() < end) { /* spin */ }
+ }
+}
+
+function _sweepOrphanConfigTmps() {
+ try {
+ const dir = path.dirname(configStore.filePath);
+ const isAlive = (pid) => {
+ try { process.kill(pid, 0); return true; } catch (e) { return !!(e && e.code === 'EPERM'); }
+ };
+ const orphans = selectOrphanTmps(fs.readdirSync(dir), {
+ baseName: path.basename(configStore.filePath),
+ currentPid: process.pid,
+ isAlive
+ });
+ for (const file of orphans) {
+ try { fs.unlinkSync(path.join(dir, file)); } catch {}
+ }
+ } catch {}
+}
+
+// --- Folder Monitor ---
+function startFolderMonitor(settings) {
+ try {
+ folderMonitor.stop();
+ folderMonitor.removeAllListeners();
+ folderMonitor.on('new-files', (files) => {
+ debugLog(`folder-monitor: ${files.length} new file(s)`);
+ safeSend('folder-monitor:new-files', files);
+ });
+ folderMonitor.on('error', (err) => {
+ debugLog(`folder-monitor error: ${err.message}`);
+ });
+ folderMonitor.start(settings);
+ debugLog(`folder-monitor started: ${settings.folderPath}`);
+ } catch (err) {
+ debugLog(`folder-monitor start failed: ${err.message}`);
+ throw err;
+ }
+}
+
+ipcMain.handle('folder-monitor:start', (_event, settings) => {
+ startFolderMonitor(settings);
+ return { ok: true };
+});
+
+ipcMain.handle('folder-monitor:stop', () => {
+ folderMonitor.stop();
+ debugLog('folder-monitor stopped');
+ return { ok: true };
+});
+
+ipcMain.handle('folder-monitor:status', () => {
+ return folderMonitor.status();
+});
+
+ipcMain.handle('folder-monitor:select-folder', async () => {
+ const result = await dialog.showOpenDialog(mainWindow, {
+ properties: ['openDirectory']
+ });
+ if (result.canceled || !result.filePaths.length) return null;
+ return result.filePaths[0];
+});
+
+// --- Remote Control ---
+function generateToken() {
+ const crypto = require('crypto');
+ return crypto.randomBytes(32).toString('hex');
+}
+
+// --- Remote Diagnostics (read-only) ---
+function _diagAppInfo() {
+ return {
+ name: app.getName(),
+ version: app.getVersion(),
+ electron: process.versions.electron,
+ node: process.versions.node,
+ chrome: process.versions.chrome,
+ packaged: app.isPackaged,
+ pid: process.pid,
+ uptimeSec: Math.round(process.uptime())
+ };
+}
+
+function _diagSystemInfo() {
+ const os = require('os');
+ let disk = null;
+ try {
+ const sf = fs.statfsSync(app.getPath('userData'));
+ disk = { freeBytes: sf.bavail * sf.bsize, totalBytes: sf.blocks * sf.bsize };
+ } catch {}
+ return {
+ platform: process.platform,
+ arch: process.arch,
+ osType: os.type(),
+ osRelease: os.release(),
+ hostname: os.hostname(),
+ totalMemBytes: os.totalmem(),
+ freeMemBytes: os.freemem(),
+ cpuCount: (os.cpus() || []).length,
+ osUptimeSec: Math.round(os.uptime()),
+ disk
+ };
+}
+
+function _diagAgentInfo() {
+ const cfg = configStore.load();
+ const diag = (cfg.globalSettings && cfg.globalSettings.diagnostics) || {};
+ return {
+ version: app.getVersion(),
+ port: diag.port || 9110,
+ bindAddress: _diagBindHost(diag),
+ clientCount: diagnosticAgent ? diagnosticAgent.getClientCount() : 0,
+ lastAccess: diagnosticAgent ? diagnosticAgent.getLastAccess() : null
+ };
+}
+
+function _buildDiagnosticHandler() {
+ const collectors = createCollectors({
+ loadConfig: () => configStore.load(),
+ loadHistory: () => configStore.loadHistory(),
+ getAllLogPaths,
+ support: { sanitizeConfig, collectSecretValues, redactLogText, valueScrub, collectFile, REDACTED },
+ stats,
+ appInfo: _diagAppInfo,
+ systemInfo: _diagSystemInfo,
+ agentInfo: _diagAgentInfo
+ });
+ const agent = createAgent(collectors);
+ return (msg, _client, reply) => {
+ let result;
+ try { result = agent.handle(msg.op, msg.args); }
+ catch (e) { result = { ok: false, error: String((e && e.message) || e) }; }
+ reply(result);
+ };
+}
+
+function _getSuggestedRemoteHosts() {
+ const os = require('os');
+ const hosts = [];
+ try {
+ for (const entry of Object.values(os.networkInterfaces())) {
+ for (const net of (entry || [])) {
+ if (net && net.family === 'IPv4' && !net.internal && net.address) hosts.push(net.address);
+ }
+ }
+ } catch {}
+ return [...new Set(hosts)];
+}
+
+function _diagAllowlist(diag) {
+ return Array.isArray(diag && diag.allowlist) ? diag.allowlist.map((x) => String(x).trim()).filter(Boolean) : [];
+}
+
+function _diagBindHost(diag) {
+ const mode = (diag && diag.bindMode) || 'local';
+ if (mode === 'network' && _diagAllowlist(diag).length > 0) return '0.0.0.0';
+ return '127.0.0.1';
+}
+
+function _diagPublicHost(diag) {
+ const explicit = String((diag && diag.publicHost) || '').trim();
+ if (explicit) return explicit;
+ if (_diagBindHost(diag) === '127.0.0.1') return '127.0.0.1';
+ return _getSuggestedRemoteHosts()[0] || '127.0.0.1';
+}
+
+function buildDiagnosticCode(diag, fp) {
+ const payload = { v: 1, h: _diagPublicHost(diag), p: diag.port || 9110, t: diag.token, n: diag.label || require('os').hostname() };
+ if (fp) { payload.fp = fp; payload.s = 'wss'; }
+ return 'mhu1_' + Buffer.from(JSON.stringify(payload)).toString('base64url');
+}
+
+async function startDiagnosticAgent() {
+ if (diagnosticAgent) { try { diagnosticAgent.stop(); } catch {} diagnosticAgent = null; }
+ const config = configStore.load();
+ const diag = config.globalSettings && config.globalSettings.diagnostics;
+ if (!diag || !diag.enabled) return;
+
+ let token = diag.token;
+ if (!token) {
+ token = generateToken();
+ const gs = { ...config.globalSettings, diagnostics: { ...diag, token, codeIssuedAt: Date.now() } };
+ await configStore.save({ globalSettings: gs });
+ }
+
+ if (!_diagHandler) _diagHandler = _buildDiagnosticHandler();
+ const host = _diagBindHost(diag);
+ const allowlist = _diagAllowlist(diag);
+ diagnosticAgent = new RemoteServer();
+ try {
+ await diagnosticAgent.start({
+ port: diag.port || 9110,
+ host,
+ token,
+ diagnosticMode: true,
+ allowlist,
+ onDiagnosticRequest: _diagHandler
+ });
+ debugLog(`diagnostics-agent started on ${host}:${diagnosticAgent.getPort()} (allowlist ${allowlist.length})`);
+ } catch (e) {
+ debugLog(`diagnostics-agent start failed: ${e.message}`);
+ diagnosticAgent = null;
+ }
+}
+
+function stopDiagnosticAgent() {
+ if (diagnosticAgent) { try { diagnosticAgent.stop(); } catch {} diagnosticAgent = null; }
+}
+
+ipcMain.handle('diagnostics:get-settings', () => {
+ const cfg = configStore.load();
+ const diag = (cfg.globalSettings && cfg.globalSettings.diagnostics) || {};
+ return {
+ enabled: !!diag.enabled,
+ port: diag.port || 9110,
+ bindMode: diag.bindMode === 'network' ? 'network' : 'local',
+ bindAddress: _diagBindHost(diag),
+ publicHost: diag.publicHost || '',
+ allowlist: _diagAllowlist(diag),
+ suggestedHosts: _getSuggestedRemoteHosts(),
+ label: diag.label || require('os').hostname(),
+ codeIssuedAt: diag.codeIssuedAt || 0,
+ code: diag.token ? buildDiagnosticCode(diag) : ''
+ };
+});
+
+ipcMain.handle('diagnostics:save-settings', async (_e, incoming) => {
+ assertConfigWriteAllowed();
+ const cfg = configStore.load();
+ const cur = (cfg.globalSettings && cfg.globalSettings.diagnostics) || {};
+ const next = {
+ ...cur,
+ enabled: !!(incoming && incoming.enabled),
+ port: (incoming && Number(incoming.port)) || cur.port || 9110,
+ bindMode: (incoming && incoming.bindMode === 'network') ? 'network' : 'local',
+ publicHost: (incoming && incoming.publicHost != null) ? String(incoming.publicHost).trim() : (cur.publicHost || ''),
+ allowlist: (incoming && Array.isArray(incoming.allowlist))
+ ? incoming.allowlist.map((x) => String(x).trim()).filter(Boolean)
+ : _diagAllowlist(cur),
+ label: (incoming && incoming.label != null) ? String(incoming.label) : cur.label
+ };
+ next.bindAddress = _diagBindHost(next);
+ const gs = { ...cfg.globalSettings, diagnostics: next };
+ await configStore.save({ globalSettings: gs });
+ await startDiagnosticAgent();
+ return { ok: true, bindAddress: next.bindAddress, allowlistCount: next.allowlist.length };
+});
+
+ipcMain.handle('diagnostics:regenerate', async () => {
+ assertConfigWriteAllowed();
+ const cfg = configStore.load();
+ const cur = (cfg.globalSettings && cfg.globalSettings.diagnostics) || {};
+ const next = { ...cur, token: generateToken(), codeIssuedAt: Date.now() };
+ const gs = { ...cfg.globalSettings, diagnostics: next };
+ await configStore.save({ globalSettings: gs });
+ if (next.enabled) await startDiagnosticAgent();
+ return { ok: true, code: buildDiagnosticCode(next), codeIssuedAt: next.codeIssuedAt };
+});
+
+ipcMain.handle('diagnostics:status', () => {
+ const cfg = configStore.load();
+ const diag = (cfg.globalSettings && cfg.globalSettings.diagnostics) || {};
+ return {
+ running: !!diagnosticAgent,
+ port: diagnosticAgent ? diagnosticAgent.getPort() : (diag.port || 9110),
+ bindMode: diag.bindMode === 'network' ? 'network' : 'local',
+ bindAddress: _diagBindHost(diag),
+ publicHost: _diagPublicHost(diag),
+ allowlistCount: _diagAllowlist(diag).length,
+ clientCount: diagnosticAgent ? diagnosticAgent.getClientCount() : 0,
+ lastAccess: diagnosticAgent ? diagnosticAgent.getLastAccess() : null
+ };
+});
+
+function createCaptureWindow() {
+ if (captureWindow && !captureWindow.isDestroyed()) return;
+ captureWindowReady = false;
+ captureWindow = new BrowserWindow({
+ show: false,
+ webPreferences: {
+ contextIsolation: true,
+ nodeIntegration: false,
+ preload: path.join(__dirname, 'lib', 'remote-capture-preload.js')
+ }
+ });
+ captureWindow.loadFile(path.join(__dirname, 'lib', 'remote-capture.html'));
+
+ // Wait for window to be fully loaded before sending signaling messages
+ captureWindow.webContents.on('dom-ready', () => {
+ debugLog('remote: capture window ready, draining', signalingQueue.length, 'queued messages');
+ captureWindowReady = true;
+ for (const msg of signalingQueue) {
+ captureWindow.webContents.send('remote:signaling-to-capture', msg);
+ }
+ signalingQueue = [];
+ });
+
+ // Crash recovery: if hidden window closes unexpectedly while clients connected, recreate it
+ captureWindow.on('closed', () => {
+ captureWindow = null;
+ captureWindowReady = false;
+ signalingQueue = [];
+ if (remoteServer && remoteServer.getClientCount() > 0) {
+ debugLog('remote: capture window crashed, recreating...');
+ createCaptureWindow();
+ }
+ });
+}
+
+function destroyCaptureWindow() {
+ if (captureWindow && !captureWindow.isDestroyed()) {
+ captureWindow.close();
+ captureWindow = null;
+ }
+}
+
+async function startRemoteServer() {
+ if (remoteServer) {
+ remoteServer.stop();
+ remoteServer = null;
+ }
+
+ const config = configStore.load();
+ const remote = config.globalSettings && config.globalSettings.remote;
+ if (!remote || !remote.enabled) return;
+
+ let token = remote.token;
+ if (!token) {
+ const canonical = await configStore.saveRemoteSettings(remote, generateToken);
+ token = canonical.token;
+ }
+
+ remoteServer = new RemoteServer();
+ try {
+ await remoteServer.start({
+ port: remote.port || 9100,
+ token,
+ allowInput: remote.allowInput !== false,
+ mainWindow,
+ onSignalingToCapture: (data) => {
+ if (!captureWindow || captureWindow.isDestroyed()) {
+ debugLog('remote: signaling dropped, no capture window');
+ return;
+ }
+ if (captureWindowReady) {
+ captureWindow.webContents.send('remote:signaling-to-capture', data);
+ } else {
+ debugLog('remote: capture window not ready, queuing', data.type, 'message');
+ signalingQueue.push(data);
+ }
+ },
+ onCreateCaptureWindow: () => createCaptureWindow(),
+ onDestroyCaptureWindow: () => destroyCaptureWindow()
+ });
+ } catch (error) {
+ try { remoteServer.stop(); } catch {}
+ remoteServer = null;
+ destroyCaptureWindow();
+ throw error;
+ }
+
+ debugLog(`remote-server started on port ${remoteServer.getPort()}`);
+}
+
+// IPC: Signaling from capture window back to dashboard client
+ipcMain.on('remote:signaling-from-capture', (_event, data) => {
+ if (remoteServer && data.clientId) {
+ remoteServer.sendToClient(data.clientId, data);
+ }
+});
+
+// IPC: Debug logging from capture window
+ipcMain.on('remote:capture-log', (_event, msg) => {
+ debugLog('remote-capture:', msg);
+});
+
+// IPC: Input events from capture window
+ipcMain.on('remote:input-event', (_event, data) => {
+ if (!mainWindow || mainWindow.isDestroyed()) return;
+
+ const config = configStore.load();
+ const remote = config.globalSettings && config.globalSettings.remote;
+ if (!remote || !remote.allowInput) return;
+ if (data.role !== 'admin') return;
+
+ // Capture includes window frame (title bar) but NOT invisible DWM borders
+ // sendInputEvent coordinates are relative to web content area
+ const winBounds = mainWindow.getBounds();
+ const contentBounds = mainWindow.getContentBounds();
+ // Windows 10/11: getBounds() includes ~7px invisible resize borders not in capture
+ const dwm = process.platform === 'win32' ? 7 : 0;
+ const capturedW = winBounds.width - 2 * dwm;
+ const capturedH = winBounds.height - dwm; // only bottom has invisible border
+ const contentOffsetX = contentBounds.x - (winBounds.x + dwm);
+ const contentOffsetY = contentBounds.y - winBounds.y;
+ const rawX = typeof data.x === 'number' && isFinite(data.x) ? data.x : 0;
+ const rawY = typeof data.y === 'number' && isFinite(data.y) ? data.y : 0;
+ const x = Math.round(rawX * capturedW - contentOffsetX);
+ const y = Math.round(rawY * capturedH - contentOffsetY);
+
+ switch (data.type) {
+ case 'mousemove':
+ mainWindow.webContents.sendInputEvent({ type: 'mouseMove', x, y });
+ break;
+ case 'mousedown':
+ mainWindow.webContents.sendInputEvent({
+ type: 'mouseDown', x, y,
+ button: data.button === 'right' ? 'right' : 'left',
+ clickCount: 1
+ });
+ break;
+ case 'mouseup':
+ mainWindow.webContents.sendInputEvent({
+ type: 'mouseUp', x, y,
+ button: data.button === 'right' ? 'right' : 'left',
+ clickCount: 1
+ });
+ break;
+ case 'scroll':
+ mainWindow.webContents.sendInputEvent({
+ type: 'mouseWheel', x, y,
+ deltaX: data.deltaX || 0,
+ deltaY: data.deltaY || 0
+ });
+ break;
+ case 'keydown':
+ mainWindow.webContents.sendInputEvent({
+ type: 'keyDown',
+ keyCode: data.key,
+ modifiers: buildModifiers(data)
+ });
+ if (data.key.length === 1) {
+ mainWindow.webContents.sendInputEvent({
+ type: 'char',
+ keyCode: data.key,
+ modifiers: buildModifiers(data)
+ });
+ }
+ break;
+ case 'keyup':
+ mainWindow.webContents.sendInputEvent({
+ type: 'keyUp',
+ keyCode: data.key,
+ modifiers: buildModifiers(data)
+ });
+ break;
+ }
+});
+
+function buildModifiers(data) {
+ const mods = [];
+ if (data.shift) mods.push('shift');
+ if (data.ctrl) mods.push('control');
+ if (data.alt) mods.push('alt');
+ return mods;
+}
+
+// IPC: Get capture source ID (desktopCapturer must run in main process in Electron 33+)
+ipcMain.handle('remote:get-capture-source-id', async () => {
+ if (!mainWindow || mainWindow.isDestroyed()) {
+ debugLog('remote: capture source - mainWindow not available');
+ return null;
+ }
+ // Use getMediaSourceId() for exact window capture without enumeration
+ const sourceId = mainWindow.getMediaSourceId();
+ debugLog('remote: capture source - getMediaSourceId:', sourceId);
+ if (sourceId) return sourceId;
+
+ // Fallback: enumerate sources
+ const { desktopCapturer } = require('electron');
+ const sources = await desktopCapturer.getSources({ types: ['window', 'screen'] });
+ const title = mainWindow.getTitle();
+ debugLog('remote: capture source - fallback, looking for title:', title);
+ let source = sources.find(s => s.name === title);
+ if (!source) source = sources.find(s => s.name.includes('Multi-Hoster'));
+ if (!source) source = sources.find(s => s.id.startsWith('screen:'));
+ debugLog('remote: capture source -', source ? `found: ${source.name} (${source.id})` : 'NONE FOUND');
+ return source ? source.id : null;
+});
+
+// IPC: Client count updates from capture window
+ipcMain.on('remote:client-count', (_event, count) => {
+ safeSend('remote:client-count', count);
+});
+
+// IPC: Remote settings
+ipcMain.handle('remote:get-settings', () => {
+ const config = configStore.load();
+ return config.globalSettings && config.globalSettings.remote || {};
+});
+
+ipcMain.handle('remote:save-settings', async (_event, remoteSettings) => {
+ assertConfigWriteAllowed();
+ const canonicalSettings = await configStore.saveRemoteSettings(remoteSettings, generateToken);
+
+ let runtimeError = '';
+ try {
+ if (canonicalSettings.enabled) {
+ await startRemoteServer();
+ } else if (remoteServer) {
+ remoteServer.stop();
+ remoteServer = null;
+ destroyCaptureWindow();
+ debugLog('remote-server stopped');
+ }
+ } catch (error) {
+ runtimeError = error && error.message ? error.message : String(error);
+ }
+ return {
+ saved: true,
+ runtimeError,
+ settings: canonicalSettings
+ };
+});
+
+ipcMain.handle('remote:generate-token', () => {
+ return generateToken();
+});
+
+ipcMain.handle('remote:status', () => {
+ return {
+ running: !!remoteServer,
+ port: remoteServer ? remoteServer.getPort() : null,
+ clientCount: remoteServer ? remoteServer.getClientCount() : 0
+ };
+});
+
+// --- Always on top ---
+ipcMain.handle('set-always-on-top', async (_event, value) => {
+ assertConfigWriteAllowed();
+ if (mainWindow && !mainWindow.isDestroyed()) {
+ mainWindow.setAlwaysOnTop(!!value);
+ }
+ await configStore.save({ globalSettings: { ...configStore.load().globalSettings, alwaysOnTop: !!value } });
+ return true;
+});
+
+ipcMain.handle('get-always-on-top', () => {
+ if (mainWindow && !mainWindow.isDestroyed()) {
+ return mainWindow.isAlwaysOnTop();
+ }
+ return false;
+});
+
+// --- Drop Target Window ---
+function createDropTargetWindow() {
+ if (dropTargetWindow && !dropTargetWindow.isDestroyed()) return;
+ const { screen } = require('electron');
+ const display = screen.getPrimaryDisplay();
+ const { width, height } = display.workAreaSize;
+ dropTargetWindow = new BrowserWindow({
+ width: 120,
+ height: 120,
+ x: width - 140,
+ y: height - 140,
+ frame: false,
+ transparent: true,
+ alwaysOnTop: true,
+ skipTaskbar: true,
+ resizable: false,
+ minimizable: false,
+ maximizable: false,
+ focusable: false,
+ webPreferences: {
+ contextIsolation: true,
+ nodeIntegration: false,
+ preload: path.join(__dirname, 'preload-drop-target.js')
+ }
+ });
+ dropTargetWindow.loadFile('renderer/drop-target.html');
+ dropTargetWindow.on('closed', () => { dropTargetWindow = null; });
+}
+
+function destroyDropTargetWindow() {
+ if (dropTargetWindow && !dropTargetWindow.isDestroyed()) {
+ dropTargetWindow.close();
+ dropTargetWindow = null;
+ }
+}
+
+ipcMain.handle('show-drop-target', () => {
+ createDropTargetWindow();
+ return true;
+});
+
+ipcMain.handle('hide-drop-target', () => {
+ destroyDropTargetWindow();
+ return true;
+});
+
+ipcMain.on('drop-target:files', (_event, paths) => {
+ if (mainWindow && !mainWindow.isDestroyed()) {
+ if (!mainWindow.isVisible() || mainWindow.isMinimized()) {
+ mainWindow.show();
+ mainWindow.focus();
+ }
+ safeSend('drop-target:files', paths);
+ }
+});
+
+// --- Shutdown after finish ---
+let shutdownMode = 'nothing';
+let shutdownTimer = null;
+
+ipcMain.handle('set-shutdown-after-finish', (_event, mode) => {
+ shutdownMode = mode || 'nothing';
+ // Cancel active countdown if mode changed to 'nothing'
+ if (shutdownMode === 'nothing' && shutdownTimer) {
+ clearTimeout(shutdownTimer);
+ shutdownTimer = null;
+ }
+ return true;
+});
+
+ipcMain.handle('get-shutdown-after-finish', () => {
+ return shutdownMode;
+});
+
+ipcMain.handle('cancel-shutdown', () => {
+ if (shutdownTimer) {
+ clearTimeout(shutdownTimer);
+ shutdownTimer = null;
+ }
+ shutdownMode = 'nothing';
+ return true;
+});
+
+function handleShutdownAfterFinish() {
+ if (shutdownMode === 'nothing') return;
+
+ const { exec } = require('child_process');
+
+ // Notify renderer
+ safeSend('shutdown-countdown', { mode: shutdownMode, seconds: 60 });
+
+ // Clear any previous countdown to prevent orphaned timers
+ if (shutdownTimer) clearTimeout(shutdownTimer);
+
+ shutdownTimer = setTimeout(() => {
+ // Read current mode at execution time (not captured at scheduling time)
+ if (shutdownMode === 'shutdown') {
+ exec('shutdown /s /t 0', (err) => { if (err) debugLog(`shutdown failed: ${err.message}`); });
+ } else if (shutdownMode === 'restart') {
+ exec('shutdown /r /t 0', (err) => { if (err) debugLog(`restart failed: ${err.message}`); });
+ } else if (shutdownMode === 'sleep') {
+ exec('rundll32.exe powrprof.dll,SetSuspendState 0,1,0', (err) => { if (err) debugLog(`sleep failed: ${err.message}`); });
+ }
+ // else: mode was changed to 'nothing' during countdown — do nothing
+ }, 60000);
+}
+
+// Restore always-on-top from config on window creation
+app.on('browser-window-created', () => {
+ const config = configStore.load();
+ if (config.globalSettings && config.globalSettings.alwaysOnTop && mainWindow) {
+ mainWindow.setAlwaysOnTop(true);
+ }
+});
diff --git a/package-lock.json b/package-lock.json
new file mode 100644
index 0000000..e77fd5a
--- /dev/null
+++ b/package-lock.json
@@ -0,0 +1,4948 @@
+{
+ "name": "multi-hoster-uploader",
+ "version": "2.0.6",
+ "lockfileVersion": 3,
+ "requires": true,
+ "packages": {
+ "": {
+ "name": "multi-hoster-uploader",
+ "version": "2.0.6",
+ "dependencies": {
+ "chokidar": "^3.6.0",
+ "undici": "^7.29.0",
+ "ws": "^8.21.0"
+ },
+ "devDependencies": {
+ "electron": "^41.3.0",
+ "electron-builder": "^26.8.1",
+ "eslint": "^10.1.0",
+ "eslint-plugin-security": "^4.0.0",
+ "rcedit": "^4.0.1"
+ }
+ },
+ "node_modules/@develar/schema-utils": {
+ "version": "2.6.5",
+ "resolved": "https://registry.npmjs.org/@develar/schema-utils/-/schema-utils-2.6.5.tgz",
+ "integrity": "sha512-0cp4PsWQ/9avqTVMCtZ+GirikIA36ikvjtHweU4/j8yLtgObI0+JUPhYFScgwlteveGB1rt3Cm8UhN04XayDig==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "ajv": "^6.12.0",
+ "ajv-keywords": "^3.4.1"
+ },
+ "engines": {
+ "node": ">= 8.9.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/webpack"
+ }
+ },
+ "node_modules/@electron/asar": {
+ "version": "3.4.1",
+ "resolved": "https://registry.npmjs.org/@electron/asar/-/asar-3.4.1.tgz",
+ "integrity": "sha512-i4/rNPRS84t0vSRa2HorerGRXWyF4vThfHesw0dmcWHp+cspK743UanA0suA5Q5y8kzY2y6YKrvbIUn69BCAiA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "commander": "^5.0.0",
+ "glob": "^7.1.6",
+ "minimatch": "^3.0.4"
+ },
+ "bin": {
+ "asar": "bin/asar.js"
+ },
+ "engines": {
+ "node": ">=10.12.0"
+ }
+ },
+ "node_modules/@electron/asar/node_modules/balanced-match": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+ "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@electron/asar/node_modules/brace-expansion": {
+ "version": "1.1.14",
+ "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.14.tgz",
+ "integrity": "sha512-MWPGfDxnyzKU7rNOW9SP/c50vi3xrmrua/+6hfPbCS2ABNWfx24vPidzvC7krjU/RTo235sV776ymlsMtGKj8g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "balanced-match": "^1.0.0",
+ "concat-map": "0.0.1"
+ }
+ },
+ "node_modules/@electron/asar/node_modules/minimatch": {
+ "version": "3.1.5",
+ "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+ "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "brace-expansion": "^1.1.7"
+ },
+ "engines": {
+ "node": "*"
+ }
+ },
+ "node_modules/@electron/fuses": {
+ "version": "1.8.0",
+ "resolved": "https://registry.npmjs.org/@electron/fuses/-/fuses-1.8.0.tgz",
+ "integrity": "sha512-zx0EIq78WlY/lBb1uXlziZmDZI4ubcCXIMJ4uGjXzZW0nS19TjSPeXPAjzzTmKQlJUZm0SbmZhPKP7tuQ1SsEw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "chalk": "^4.1.1",
+ "fs-extra": "^9.0.1",
+ "minimist": "^1.2.5"
+ },
+ "bin": {
+ "electron-fuses": "dist/bin.js"
+ }
+ },
+ "node_modules/@electron/fuses/node_modules/fs-extra": {
+ "version": "9.1.0",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz",
+ "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "at-least-node": "^1.0.0",
+ "graceful-fs": "^4.2.0",
+ "jsonfile": "^6.0.1",
+ "universalify": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/@electron/fuses/node_modules/jsonfile": {
+ "version": "6.2.1",
+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz",
+ "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "universalify": "^2.0.0"
+ },
+ "optionalDependencies": {
+ "graceful-fs": "^4.1.6"
+ }
+ },
+ "node_modules/@electron/fuses/node_modules/universalify": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+ "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 10.0.0"
+ }
+ },
+ "node_modules/@electron/get": {
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/@electron/get/-/get-2.0.3.tgz",
+ "integrity": "sha512-Qkzpg2s9GnVV2I2BjRksUi43U5e6+zaQMcjoJy0C+C5oxaKl+fmckGDQFtRpZpZV0NQekuZZ+tGz7EA9TVnQtQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "debug": "^4.1.1",
+ "env-paths": "^2.2.0",
+ "fs-extra": "^8.1.0",
+ "got": "^11.8.5",
+ "progress": "^2.0.3",
+ "semver": "^6.2.0",
+ "sumchecker": "^3.0.1"
+ },
+ "engines": {
+ "node": ">=12"
+ },
+ "optionalDependencies": {
+ "global-agent": "^3.0.0"
+ }
+ },
+ "node_modules/@electron/notarize": {
+ "version": "2.5.0",
+ "resolved": "https://registry.npmjs.org/@electron/notarize/-/notarize-2.5.0.tgz",
+ "integrity": "sha512-jNT8nwH1f9X5GEITXaQ8IF/KdskvIkOFfB2CvwumsveVidzpSc+mvhhTMdAGSYF3O+Nq49lJ7y+ssODRXu06+A==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "debug": "^4.1.1",
+ "fs-extra": "^9.0.1",
+ "promise-retry": "^2.0.1"
+ },
+ "engines": {
+ "node": ">= 10.0.0"
+ }
+ },
+ "node_modules/@electron/notarize/node_modules/fs-extra": {
+ "version": "9.1.0",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz",
+ "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "at-least-node": "^1.0.0",
+ "graceful-fs": "^4.2.0",
+ "jsonfile": "^6.0.1",
+ "universalify": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/@electron/notarize/node_modules/jsonfile": {
+ "version": "6.2.1",
+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz",
+ "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "universalify": "^2.0.0"
+ },
+ "optionalDependencies": {
+ "graceful-fs": "^4.1.6"
+ }
+ },
+ "node_modules/@electron/notarize/node_modules/universalify": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+ "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 10.0.0"
+ }
+ },
+ "node_modules/@electron/osx-sign": {
+ "version": "1.3.3",
+ "resolved": "https://registry.npmjs.org/@electron/osx-sign/-/osx-sign-1.3.3.tgz",
+ "integrity": "sha512-KZ8mhXvWv2rIEgMbWZ4y33bDHyUKMXnx4M0sTyPNK/vcB81ImdeY9Ggdqy0SWbMDgmbqyQ+phgejh6V3R2QuSg==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "dependencies": {
+ "compare-version": "^0.1.2",
+ "debug": "^4.3.4",
+ "fs-extra": "^10.0.0",
+ "isbinaryfile": "^4.0.8",
+ "minimist": "^1.2.6",
+ "plist": "^3.0.5"
+ },
+ "bin": {
+ "electron-osx-flat": "bin/electron-osx-flat.js",
+ "electron-osx-sign": "bin/electron-osx-sign.js"
+ },
+ "engines": {
+ "node": ">=12.0.0"
+ }
+ },
+ "node_modules/@electron/osx-sign/node_modules/fs-extra": {
+ "version": "10.1.0",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",
+ "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "graceful-fs": "^4.2.0",
+ "jsonfile": "^6.0.1",
+ "universalify": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/@electron/osx-sign/node_modules/isbinaryfile": {
+ "version": "4.0.10",
+ "resolved": "https://registry.npmjs.org/isbinaryfile/-/isbinaryfile-4.0.10.tgz",
+ "integrity": "sha512-iHrqe5shvBUcFbmZq9zOQHBoeOhZJu6RQGrDpBgenUm/Am+F3JM2MgQj+rK3Z601fzrL5gLZWtAPH2OBaSVcyw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 8.0.0"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/gjtorikian/"
+ }
+ },
+ "node_modules/@electron/osx-sign/node_modules/jsonfile": {
+ "version": "6.2.1",
+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz",
+ "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "universalify": "^2.0.0"
+ },
+ "optionalDependencies": {
+ "graceful-fs": "^4.1.6"
+ }
+ },
+ "node_modules/@electron/osx-sign/node_modules/universalify": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+ "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 10.0.0"
+ }
+ },
+ "node_modules/@electron/rebuild": {
+ "version": "4.0.4",
+ "resolved": "https://registry.npmjs.org/@electron/rebuild/-/rebuild-4.0.4.tgz",
+ "integrity": "sha512-Rzc39XPdk/+/wBG8MfwAHohXflep0ITUfulb6Rgz3R0NeSB1noE+E9/M/cb8ftCAiyDD9PPhLuuWgE1GaInbKg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@malept/cross-spawn-promise": "^2.0.0",
+ "debug": "^4.1.1",
+ "node-abi": "^4.2.0",
+ "node-api-version": "^0.2.1",
+ "node-gyp": "^12.2.0",
+ "read-binary-file-arch": "^1.0.6"
+ },
+ "bin": {
+ "electron-rebuild": "lib/cli.js"
+ },
+ "engines": {
+ "node": ">=22.12.0"
+ }
+ },
+ "node_modules/@electron/universal": {
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/@electron/universal/-/universal-2.0.3.tgz",
+ "integrity": "sha512-Wn9sPYIVFRFl5HmwMJkARCCf7rqK/EurkfQ/rJZ14mHP3iYTjZSIOSVonEAnhWeAXwtw7zOekGRlc6yTtZ0t+g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@electron/asar": "^3.3.1",
+ "@malept/cross-spawn-promise": "^2.0.0",
+ "debug": "^4.3.1",
+ "dir-compare": "^4.2.0",
+ "fs-extra": "^11.1.1",
+ "minimatch": "^9.0.3",
+ "plist": "^3.1.0"
+ },
+ "engines": {
+ "node": ">=16.4"
+ }
+ },
+ "node_modules/@electron/universal/node_modules/balanced-match": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+ "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@electron/universal/node_modules/brace-expansion": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.0.tgz",
+ "integrity": "sha512-TN1kCZAgdgweJhWWpgKYrQaMNHcDULHkWwQIspdtjV4Y5aurRdZpjAqn6yX3FPqTA9ngHCc4hJxMAMgGfve85w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "balanced-match": "^1.0.0"
+ }
+ },
+ "node_modules/@electron/universal/node_modules/fs-extra": {
+ "version": "11.3.4",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.4.tgz",
+ "integrity": "sha512-CTXd6rk/M3/ULNQj8FBqBWHYBVYybQ3VPBw0xGKFe3tuH7ytT6ACnvzpIQ3UZtB8yvUKC2cXn1a+x+5EVQLovA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "graceful-fs": "^4.2.0",
+ "jsonfile": "^6.0.1",
+ "universalify": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=14.14"
+ }
+ },
+ "node_modules/@electron/universal/node_modules/jsonfile": {
+ "version": "6.2.1",
+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz",
+ "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "universalify": "^2.0.0"
+ },
+ "optionalDependencies": {
+ "graceful-fs": "^4.1.6"
+ }
+ },
+ "node_modules/@electron/universal/node_modules/minimatch": {
+ "version": "9.0.9",
+ "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.9.tgz",
+ "integrity": "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "brace-expansion": "^2.0.2"
+ },
+ "engines": {
+ "node": ">=16 || 14 >=14.17"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/isaacs"
+ }
+ },
+ "node_modules/@electron/universal/node_modules/universalify": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+ "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 10.0.0"
+ }
+ },
+ "node_modules/@electron/windows-sign": {
+ "version": "1.2.2",
+ "resolved": "https://registry.npmjs.org/@electron/windows-sign/-/windows-sign-1.2.2.tgz",
+ "integrity": "sha512-dfZeox66AvdPtb2lD8OsIIQh12Tp0GNCRUDfBHIKGpbmopZto2/A8nSpYYLoedPIHpqkeblZ/k8OV0Gy7PYuyQ==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "optional": true,
+ "peer": true,
+ "dependencies": {
+ "cross-dirname": "^0.1.0",
+ "debug": "^4.3.4",
+ "fs-extra": "^11.1.1",
+ "minimist": "^1.2.8",
+ "postject": "^1.0.0-alpha.6"
+ },
+ "bin": {
+ "electron-windows-sign": "bin/electron-windows-sign.js"
+ },
+ "engines": {
+ "node": ">=14.14"
+ }
+ },
+ "node_modules/@electron/windows-sign/node_modules/fs-extra": {
+ "version": "11.3.4",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.4.tgz",
+ "integrity": "sha512-CTXd6rk/M3/ULNQj8FBqBWHYBVYybQ3VPBw0xGKFe3tuH7ytT6ACnvzpIQ3UZtB8yvUKC2cXn1a+x+5EVQLovA==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "peer": true,
+ "dependencies": {
+ "graceful-fs": "^4.2.0",
+ "jsonfile": "^6.0.1",
+ "universalify": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=14.14"
+ }
+ },
+ "node_modules/@electron/windows-sign/node_modules/jsonfile": {
+ "version": "6.2.1",
+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz",
+ "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "peer": true,
+ "dependencies": {
+ "universalify": "^2.0.0"
+ },
+ "optionalDependencies": {
+ "graceful-fs": "^4.1.6"
+ }
+ },
+ "node_modules/@electron/windows-sign/node_modules/universalify": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+ "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "peer": true,
+ "engines": {
+ "node": ">= 10.0.0"
+ }
+ },
+ "node_modules/@eslint-community/eslint-utils": {
+ "version": "4.9.1",
+ "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.1.tgz",
+ "integrity": "sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "eslint-visitor-keys": "^3.4.3"
+ },
+ "engines": {
+ "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+ },
+ "funding": {
+ "url": "https://opencollective.com/eslint"
+ },
+ "peerDependencies": {
+ "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0"
+ }
+ },
+ "node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys": {
+ "version": "3.4.3",
+ "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
+ "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "engines": {
+ "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+ },
+ "funding": {
+ "url": "https://opencollective.com/eslint"
+ }
+ },
+ "node_modules/@eslint-community/regexpp": {
+ "version": "4.12.2",
+ "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.2.tgz",
+ "integrity": "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": "^12.0.0 || ^14.0.0 || >=16.0.0"
+ }
+ },
+ "node_modules/@eslint/config-array": {
+ "version": "0.23.5",
+ "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.23.5.tgz",
+ "integrity": "sha512-Y3kKLvC1dvTOT+oGlqNQ1XLqK6D1HU2YXPc52NmAlJZbMMWDzGYXMiPRJ8TYD39muD/OTjlZmNJ4ib7dvSrMBA==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "dependencies": {
+ "@eslint/object-schema": "^3.0.5",
+ "debug": "^4.3.1",
+ "minimatch": "^10.2.4"
+ },
+ "engines": {
+ "node": "^20.19.0 || ^22.13.0 || >=24"
+ }
+ },
+ "node_modules/@eslint/config-helpers": {
+ "version": "0.5.5",
+ "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.5.5.tgz",
+ "integrity": "sha512-eIJYKTCECbP/nsKaaruF6LW967mtbQbsw4JTtSVkUQc9MneSkbrgPJAbKl9nWr0ZeowV8BfsarBmPpBzGelA2w==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "dependencies": {
+ "@eslint/core": "^1.2.1"
+ },
+ "engines": {
+ "node": "^20.19.0 || ^22.13.0 || >=24"
+ }
+ },
+ "node_modules/@eslint/core": {
+ "version": "1.2.1",
+ "resolved": "https://registry.npmjs.org/@eslint/core/-/core-1.2.1.tgz",
+ "integrity": "sha512-MwcE1P+AZ4C6DWlpin/OmOA54mmIZ/+xZuJiQd4SyB29oAJjN30UW9wkKNptW2ctp4cEsvhlLY/CsQ1uoHDloQ==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "dependencies": {
+ "@types/json-schema": "^7.0.15"
+ },
+ "engines": {
+ "node": "^20.19.0 || ^22.13.0 || >=24"
+ }
+ },
+ "node_modules/@eslint/object-schema": {
+ "version": "3.0.5",
+ "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-3.0.5.tgz",
+ "integrity": "sha512-vqTaUEgxzm+YDSdElad6PiRoX4t8VGDjCtt05zn4nU810UIx/uNEV7/lZJ6KwFThKZOzOxzXy48da+No7HZaMw==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "engines": {
+ "node": "^20.19.0 || ^22.13.0 || >=24"
+ }
+ },
+ "node_modules/@eslint/plugin-kit": {
+ "version": "0.7.1",
+ "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.7.1.tgz",
+ "integrity": "sha512-rZAP3aVgB9ds9KOeUSL+zZ21hPmo8dh6fnIFwRQj5EAZl9gzR7wxYbYXYysAM8CTqGmUGyp2S4kUdV17MnGuWQ==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "dependencies": {
+ "@eslint/core": "^1.2.1",
+ "levn": "^0.4.1"
+ },
+ "engines": {
+ "node": "^20.19.0 || ^22.13.0 || >=24"
+ }
+ },
+ "node_modules/@humanfs/core": {
+ "version": "0.19.1",
+ "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.1.tgz",
+ "integrity": "sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "engines": {
+ "node": ">=18.18.0"
+ }
+ },
+ "node_modules/@humanfs/node": {
+ "version": "0.16.7",
+ "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.7.tgz",
+ "integrity": "sha512-/zUx+yOsIrG4Y43Eh2peDeKCxlRt/gET6aHfaKpuq267qXdYDFViVHfMaLyygZOnl0kGWxFIgsBy8QFuTLUXEQ==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "dependencies": {
+ "@humanfs/core": "^0.19.1",
+ "@humanwhocodes/retry": "^0.4.0"
+ },
+ "engines": {
+ "node": ">=18.18.0"
+ }
+ },
+ "node_modules/@humanwhocodes/module-importer": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz",
+ "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "engines": {
+ "node": ">=12.22"
+ },
+ "funding": {
+ "type": "github",
+ "url": "https://github.com/sponsors/nzakas"
+ }
+ },
+ "node_modules/@humanwhocodes/retry": {
+ "version": "0.4.3",
+ "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.4.3.tgz",
+ "integrity": "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "engines": {
+ "node": ">=18.18"
+ },
+ "funding": {
+ "type": "github",
+ "url": "https://github.com/sponsors/nzakas"
+ }
+ },
+ "node_modules/@isaacs/fs-minipass": {
+ "version": "4.0.1",
+ "resolved": "https://registry.npmjs.org/@isaacs/fs-minipass/-/fs-minipass-4.0.1.tgz",
+ "integrity": "sha512-wgm9Ehl2jpeqP3zw/7mo3kRHFp5MEDhqAdwy1fTGkHAwnkGOVsgpvQhL8B5n1qlb01jV3n/bI0ZfZp5lWA1k4w==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "minipass": "^7.0.4"
+ },
+ "engines": {
+ "node": ">=18.0.0"
+ }
+ },
+ "node_modules/@malept/cross-spawn-promise": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/@malept/cross-spawn-promise/-/cross-spawn-promise-2.0.0.tgz",
+ "integrity": "sha512-1DpKU0Z5ThltBwjNySMC14g0CkbyhCaz9FkhxqNsZI6uAPJXFS8cMXlBKo26FJ8ZuW6S9GCMcR9IO5k2X5/9Fg==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "individual",
+ "url": "https://github.com/sponsors/malept"
+ },
+ {
+ "type": "tidelift",
+ "url": "https://tidelift.com/subscription/pkg/npm-.malept-cross-spawn-promise?utm_medium=referral&utm_source=npm_fund"
+ }
+ ],
+ "license": "Apache-2.0",
+ "dependencies": {
+ "cross-spawn": "^7.0.1"
+ },
+ "engines": {
+ "node": ">= 12.13.0"
+ }
+ },
+ "node_modules/@malept/flatpak-bundler": {
+ "version": "0.4.0",
+ "resolved": "https://registry.npmjs.org/@malept/flatpak-bundler/-/flatpak-bundler-0.4.0.tgz",
+ "integrity": "sha512-9QOtNffcOF/c1seMCDnjckb3R9WHcG34tky+FHpNKKCW0wc/scYLwMtO+ptyGUfMW0/b/n4qRiALlaFHc9Oj7Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "debug": "^4.1.1",
+ "fs-extra": "^9.0.0",
+ "lodash": "^4.17.15",
+ "tmp-promise": "^3.0.2"
+ },
+ "engines": {
+ "node": ">= 10.0.0"
+ }
+ },
+ "node_modules/@malept/flatpak-bundler/node_modules/fs-extra": {
+ "version": "9.1.0",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz",
+ "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "at-least-node": "^1.0.0",
+ "graceful-fs": "^4.2.0",
+ "jsonfile": "^6.0.1",
+ "universalify": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/@malept/flatpak-bundler/node_modules/jsonfile": {
+ "version": "6.2.1",
+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz",
+ "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "universalify": "^2.0.0"
+ },
+ "optionalDependencies": {
+ "graceful-fs": "^4.1.6"
+ }
+ },
+ "node_modules/@malept/flatpak-bundler/node_modules/universalify": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+ "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 10.0.0"
+ }
+ },
+ "node_modules/@sindresorhus/is": {
+ "version": "4.6.0",
+ "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-4.6.0.tgz",
+ "integrity": "sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sindresorhus/is?sponsor=1"
+ }
+ },
+ "node_modules/@szmarczak/http-timer": {
+ "version": "4.0.6",
+ "resolved": "https://registry.npmjs.org/@szmarczak/http-timer/-/http-timer-4.0.6.tgz",
+ "integrity": "sha512-4BAffykYOgO+5nzBWYwE3W90sBgLJoUPRWWcL8wlyiM8IB8ipJz3UMJ9KXQd1RKQXpKp8Tutn80HZtWsu2u76w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "defer-to-connect": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/@types/cacheable-request": {
+ "version": "6.0.3",
+ "resolved": "https://registry.npmjs.org/@types/cacheable-request/-/cacheable-request-6.0.3.tgz",
+ "integrity": "sha512-IQ3EbTzGxIigb1I3qPZc1rWJnH0BmSKv5QYTalEwweFvyBDLSAe24zP0le/hyi7ecGfZVlIVAg4BZqb8WBwKqw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/http-cache-semantics": "*",
+ "@types/keyv": "^3.1.4",
+ "@types/node": "*",
+ "@types/responselike": "^1.0.0"
+ }
+ },
+ "node_modules/@types/debug": {
+ "version": "4.1.13",
+ "resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.13.tgz",
+ "integrity": "sha512-KSVgmQmzMwPlmtljOomayoR89W4FynCAi3E8PPs7vmDVPe84hT+vGPKkJfThkmXs0x0jAaa9U8uW8bbfyS2fWw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/ms": "*"
+ }
+ },
+ "node_modules/@types/esrecurse": {
+ "version": "4.3.1",
+ "resolved": "https://registry.npmjs.org/@types/esrecurse/-/esrecurse-4.3.1.tgz",
+ "integrity": "sha512-xJBAbDifo5hpffDBuHl0Y8ywswbiAp/Wi7Y/GtAgSlZyIABppyurxVueOPE8LUQOxdlgi6Zqce7uoEpqNTeiUw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/estree": {
+ "version": "1.0.8",
+ "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+ "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/fs-extra": {
+ "version": "9.0.13",
+ "resolved": "https://registry.npmjs.org/@types/fs-extra/-/fs-extra-9.0.13.tgz",
+ "integrity": "sha512-nEnwB++1u5lVDM2UI4c1+5R+FYaKfaAzS4OococimjVm3nQw3TuzH5UNsocrcTBbhnerblyHj4A49qXbIiZdpA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/node": "*"
+ }
+ },
+ "node_modules/@types/http-cache-semantics": {
+ "version": "4.2.0",
+ "resolved": "https://registry.npmjs.org/@types/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz",
+ "integrity": "sha512-L3LgimLHXtGkWikKnsPg0/VFx9OGZaC+eN1u4r+OB1XRqH3meBIAVC2zr1WdMH+RHmnRkqliQAOHNJ/E0j/e0Q==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/json-schema": {
+ "version": "7.0.15",
+ "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
+ "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/keyv": {
+ "version": "3.1.4",
+ "resolved": "https://registry.npmjs.org/@types/keyv/-/keyv-3.1.4.tgz",
+ "integrity": "sha512-BQ5aZNSCpj7D6K2ksrRCTmKRLEpnPvWDiLPfoGyhZ++8YtiK9d/3DBKPJgry359X/P1PfruyYwvnvwFjuEiEIg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/node": "*"
+ }
+ },
+ "node_modules/@types/ms": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/@types/ms/-/ms-2.1.0.tgz",
+ "integrity": "sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/node": {
+ "version": "24.12.2",
+ "resolved": "https://registry.npmjs.org/@types/node/-/node-24.12.2.tgz",
+ "integrity": "sha512-A1sre26ke7HDIuY/M23nd9gfB+nrmhtYyMINbjI1zHJxYteKR6qSMX56FsmjMcDb3SMcjJg5BiRRgOCC/yBD0g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "undici-types": "~7.16.0"
+ }
+ },
+ "node_modules/@types/plist": {
+ "version": "3.0.5",
+ "resolved": "https://registry.npmjs.org/@types/plist/-/plist-3.0.5.tgz",
+ "integrity": "sha512-E6OCaRmAe4WDmWNsL/9RMqdkkzDCY1etutkflWk4c+AcjDU07Pcz1fQwTX0TQz+Pxqn9i4L1TU3UFpjnrcDgxA==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "@types/node": "*",
+ "xmlbuilder": ">=11.0.1"
+ }
+ },
+ "node_modules/@types/responselike": {
+ "version": "1.0.3",
+ "resolved": "https://registry.npmjs.org/@types/responselike/-/responselike-1.0.3.tgz",
+ "integrity": "sha512-H/+L+UkTV33uf49PH5pCAUBVPNj2nDBXTN+qS1dOwyyg24l3CcicicCA7ca+HMvJBZcFgl5r8e+RR6elsb4Lyw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/node": "*"
+ }
+ },
+ "node_modules/@types/verror": {
+ "version": "1.10.11",
+ "resolved": "https://registry.npmjs.org/@types/verror/-/verror-1.10.11.tgz",
+ "integrity": "sha512-RlDm9K7+o5stv0Co8i8ZRGxDbrTxhJtgjqjFyVh/tXQyl/rYtTKlnTvZ88oSTeYREWurwx20Js4kTuKCsFkUtg==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true
+ },
+ "node_modules/@types/yauzl": {
+ "version": "2.10.3",
+ "resolved": "https://registry.npmjs.org/@types/yauzl/-/yauzl-2.10.3.tgz",
+ "integrity": "sha512-oJoftv0LSuaDZE3Le4DbKX+KS9G36NzOeSap90UIK0yMA/NhKJhqlSGtNDORNRaIbQfzjXDrQa0ytJ6mNRGz/Q==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "@types/node": "*"
+ }
+ },
+ "node_modules/@xmldom/xmldom": {
+ "version": "0.8.13",
+ "resolved": "https://registry.npmjs.org/@xmldom/xmldom/-/xmldom-0.8.13.tgz",
+ "integrity": "sha512-KRYzxepc14G/CEpEGc3Yn+JKaAeT63smlDr+vjB8jRfgTBBI9wRj/nkQEO+ucV8p8I9bfKLWp37uHgFrbntPvw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=10.0.0"
+ }
+ },
+ "node_modules/7zip-bin": {
+ "version": "5.2.0",
+ "resolved": "https://registry.npmjs.org/7zip-bin/-/7zip-bin-5.2.0.tgz",
+ "integrity": "sha512-ukTPVhqG4jNzMro2qA9HSCSSVJN3aN7tlb+hfqYCt3ER0yWroeA2VR38MNrOHLQ/cVj+DaIMad0kFCtWWowh/A==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/abbrev": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-4.0.0.tgz",
+ "integrity": "sha512-a1wflyaL0tHtJSmLSOVybYhy22vRih4eduhhrkcjgrWGnRfrZtovJ2FRjxuTtkkj47O/baf0R86QU5OuYpz8fA==",
+ "dev": true,
+ "license": "ISC",
+ "engines": {
+ "node": "^20.17.0 || >=22.9.0"
+ }
+ },
+ "node_modules/acorn": {
+ "version": "8.16.0",
+ "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.16.0.tgz",
+ "integrity": "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==",
+ "dev": true,
+ "license": "MIT",
+ "bin": {
+ "acorn": "bin/acorn"
+ },
+ "engines": {
+ "node": ">=0.4.0"
+ }
+ },
+ "node_modules/acorn-jsx": {
+ "version": "5.3.2",
+ "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
+ "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
+ "dev": true,
+ "license": "MIT",
+ "peerDependencies": {
+ "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
+ }
+ },
+ "node_modules/agent-base": {
+ "version": "7.1.4",
+ "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+ "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 14"
+ }
+ },
+ "node_modules/ajv": {
+ "version": "6.14.0",
+ "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.14.0.tgz",
+ "integrity": "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "fast-deep-equal": "^3.1.1",
+ "fast-json-stable-stringify": "^2.0.0",
+ "json-schema-traverse": "^0.4.1",
+ "uri-js": "^4.2.2"
+ },
+ "funding": {
+ "type": "github",
+ "url": "https://github.com/sponsors/epoberezkin"
+ }
+ },
+ "node_modules/ajv-keywords": {
+ "version": "3.5.2",
+ "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz",
+ "integrity": "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==",
+ "dev": true,
+ "license": "MIT",
+ "peerDependencies": {
+ "ajv": "^6.9.1"
+ }
+ },
+ "node_modules/ansi-regex": {
+ "version": "5.0.1",
+ "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+ "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/ansi-styles": {
+ "version": "4.3.0",
+ "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+ "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "color-convert": "^2.0.1"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "funding": {
+ "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+ }
+ },
+ "node_modules/anymatch": {
+ "version": "3.1.3",
+ "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
+ "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
+ "license": "ISC",
+ "dependencies": {
+ "normalize-path": "^3.0.0",
+ "picomatch": "^2.0.4"
+ },
+ "engines": {
+ "node": ">= 8"
+ }
+ },
+ "node_modules/app-builder-bin": {
+ "version": "5.0.0-alpha.12",
+ "resolved": "https://registry.npmjs.org/app-builder-bin/-/app-builder-bin-5.0.0-alpha.12.tgz",
+ "integrity": "sha512-j87o0j6LqPL3QRr8yid6c+Tt5gC7xNfYo6uQIQkorAC6MpeayVMZrEDzKmJJ/Hlv7EnOQpaRm53k6ktDYZyB6w==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/app-builder-lib": {
+ "version": "26.8.1",
+ "resolved": "https://registry.npmjs.org/app-builder-lib/-/app-builder-lib-26.8.1.tgz",
+ "integrity": "sha512-p0Im/Dx5C4tmz8QEE1Yn4MkuPC8PrnlRneMhWJj7BBXQfNTJUshM/bp3lusdEsDbvvfJZpXWnYesgSLvwtM2Zw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@develar/schema-utils": "~2.6.5",
+ "@electron/asar": "3.4.1",
+ "@electron/fuses": "^1.8.0",
+ "@electron/get": "^3.0.0",
+ "@electron/notarize": "2.5.0",
+ "@electron/osx-sign": "1.3.3",
+ "@electron/rebuild": "^4.0.3",
+ "@electron/universal": "2.0.3",
+ "@malept/flatpak-bundler": "^0.4.0",
+ "@types/fs-extra": "9.0.13",
+ "async-exit-hook": "^2.0.1",
+ "builder-util": "26.8.1",
+ "builder-util-runtime": "9.5.1",
+ "chromium-pickle-js": "^0.2.0",
+ "ci-info": "4.3.1",
+ "debug": "^4.3.4",
+ "dotenv": "^16.4.5",
+ "dotenv-expand": "^11.0.6",
+ "ejs": "^3.1.8",
+ "electron-publish": "26.8.1",
+ "fs-extra": "^10.1.0",
+ "hosted-git-info": "^4.1.0",
+ "isbinaryfile": "^5.0.0",
+ "jiti": "^2.4.2",
+ "js-yaml": "^4.1.0",
+ "json5": "^2.2.3",
+ "lazy-val": "^1.0.5",
+ "minimatch": "^10.0.3",
+ "plist": "3.1.0",
+ "proper-lockfile": "^4.1.2",
+ "resedit": "^1.7.0",
+ "semver": "~7.7.3",
+ "tar": "^7.5.7",
+ "temp-file": "^3.4.0",
+ "tiny-async-pool": "1.3.0",
+ "which": "^5.0.0"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ },
+ "peerDependencies": {
+ "dmg-builder": "26.8.1",
+ "electron-builder-squirrel-windows": "26.8.1"
+ }
+ },
+ "node_modules/app-builder-lib/node_modules/@electron/get": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/@electron/get/-/get-3.1.0.tgz",
+ "integrity": "sha512-F+nKc0xW+kVbBRhFzaMgPy3KwmuNTYX1fx6+FxxoSnNgwYX6LD7AKBTWkU0MQ6IBoe7dz069CNkR673sPAgkCQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "debug": "^4.1.1",
+ "env-paths": "^2.2.0",
+ "fs-extra": "^8.1.0",
+ "got": "^11.8.5",
+ "progress": "^2.0.3",
+ "semver": "^6.2.0",
+ "sumchecker": "^3.0.1"
+ },
+ "engines": {
+ "node": ">=14"
+ },
+ "optionalDependencies": {
+ "global-agent": "^3.0.0"
+ }
+ },
+ "node_modules/app-builder-lib/node_modules/@electron/get/node_modules/fs-extra": {
+ "version": "8.1.0",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-8.1.0.tgz",
+ "integrity": "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "graceful-fs": "^4.2.0",
+ "jsonfile": "^4.0.0",
+ "universalify": "^0.1.0"
+ },
+ "engines": {
+ "node": ">=6 <7 || >=8"
+ }
+ },
+ "node_modules/app-builder-lib/node_modules/@electron/get/node_modules/semver": {
+ "version": "6.3.1",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+ "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+ "dev": true,
+ "license": "ISC",
+ "bin": {
+ "semver": "bin/semver.js"
+ }
+ },
+ "node_modules/app-builder-lib/node_modules/ci-info": {
+ "version": "4.3.1",
+ "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-4.3.1.tgz",
+ "integrity": "sha512-Wdy2Igu8OcBpI2pZePZ5oWjPC38tmDVx5WKUXKwlLYkA0ozo85sLsLvkBbBn/sZaSCMFOGZJ14fvW9t5/d7kdA==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/sibiraj-s"
+ }
+ ],
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/app-builder-lib/node_modules/fs-extra": {
+ "version": "10.1.0",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",
+ "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "graceful-fs": "^4.2.0",
+ "jsonfile": "^6.0.1",
+ "universalify": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/app-builder-lib/node_modules/fs-extra/node_modules/jsonfile": {
+ "version": "6.2.1",
+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz",
+ "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "universalify": "^2.0.0"
+ },
+ "optionalDependencies": {
+ "graceful-fs": "^4.1.6"
+ }
+ },
+ "node_modules/app-builder-lib/node_modules/fs-extra/node_modules/universalify": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+ "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 10.0.0"
+ }
+ },
+ "node_modules/app-builder-lib/node_modules/isexe": {
+ "version": "3.1.5",
+ "resolved": "https://registry.npmjs.org/isexe/-/isexe-3.1.5.tgz",
+ "integrity": "sha512-6B3tLtFqtQS4ekarvLVMZ+X+VlvQekbe4taUkf/rhVO3d/h0M2rfARm/pXLcPEsjjMsFgrFgSrhQIxcSVrBz8w==",
+ "dev": true,
+ "license": "BlueOak-1.0.0",
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/app-builder-lib/node_modules/semver": {
+ "version": "7.7.4",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
+ "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+ "dev": true,
+ "license": "ISC",
+ "bin": {
+ "semver": "bin/semver.js"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/app-builder-lib/node_modules/which": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/which/-/which-5.0.0.tgz",
+ "integrity": "sha512-JEdGzHwwkrbWoGOlIHqQ5gtprKGOenpDHpxE9zVR1bWbOtYRyPPHMe9FaP6x61CmNaTThSkb0DAJte5jD+DmzQ==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "isexe": "^3.1.1"
+ },
+ "bin": {
+ "node-which": "bin/which.js"
+ },
+ "engines": {
+ "node": "^18.17.0 || >=20.5.0"
+ }
+ },
+ "node_modules/argparse": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+ "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
+ "dev": true,
+ "license": "Python-2.0"
+ },
+ "node_modules/assert-plus": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz",
+ "integrity": "sha512-NfJ4UzBCcQGLDlQq7nHxH+tv3kyZ0hHQqF5BO6J7tNJeP5do1llPr8dZ8zHonfhAu0PHAdMkSo+8o0wxg9lZWw==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "engines": {
+ "node": ">=0.8"
+ }
+ },
+ "node_modules/astral-regex": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/astral-regex/-/astral-regex-2.0.0.tgz",
+ "integrity": "sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/async": {
+ "version": "3.2.6",
+ "resolved": "https://registry.npmjs.org/async/-/async-3.2.6.tgz",
+ "integrity": "sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/async-exit-hook": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/async-exit-hook/-/async-exit-hook-2.0.1.tgz",
+ "integrity": "sha512-NW2cX8m1Q7KPA7a5M2ULQeZ2wR5qI5PAbw5L0UOMxdioVk9PMZ0h1TmyZEkPYrCvYjDlFICusOu1dlEKAAeXBw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.12.0"
+ }
+ },
+ "node_modules/asynckit": {
+ "version": "0.4.0",
+ "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+ "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/at-least-node": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/at-least-node/-/at-least-node-1.0.0.tgz",
+ "integrity": "sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==",
+ "dev": true,
+ "license": "ISC",
+ "engines": {
+ "node": ">= 4.0.0"
+ }
+ },
+ "node_modules/balanced-match": {
+ "version": "4.0.3",
+ "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.3.tgz",
+ "integrity": "sha512-1pHv8LX9CpKut1Zp4EXey7Z8OfH11ONNH6Dhi2WDUt31VVZFXZzKwXcysBgqSumFCmR+0dqjMK5v5JiFHzi0+g==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": "20 || >=22"
+ }
+ },
+ "node_modules/base64-js": {
+ "version": "1.5.1",
+ "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
+ "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/feross"
+ },
+ {
+ "type": "patreon",
+ "url": "https://www.patreon.com/feross"
+ },
+ {
+ "type": "consulting",
+ "url": "https://feross.org/support"
+ }
+ ],
+ "license": "MIT"
+ },
+ "node_modules/binary-extensions": {
+ "version": "2.3.0",
+ "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz",
+ "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/boolean": {
+ "version": "3.2.0",
+ "resolved": "https://registry.npmjs.org/boolean/-/boolean-3.2.0.tgz",
+ "integrity": "sha512-d0II/GO9uf9lfUHH2BQsjxzRJZBdsjgsBiW4BvhWk/3qoKwQFjIDVN19PfX8F2D/r9PCMTtLWjYVCFrpeYUzsw==",
+ "deprecated": "Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.",
+ "dev": true,
+ "license": "MIT",
+ "optional": true
+ },
+ "node_modules/brace-expansion": {
+ "version": "5.0.5",
+ "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.5.tgz",
+ "integrity": "sha512-VZznLgtwhn+Mact9tfiwx64fA9erHH/MCXEUfB/0bX/6Fz6ny5EGTXYltMocqg4xFAQZtnO3DHWWXi8RiuN7cQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "balanced-match": "^4.0.2"
+ },
+ "engines": {
+ "node": "18 || 20 || >=22"
+ }
+ },
+ "node_modules/braces": {
+ "version": "3.0.3",
+ "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
+ "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
+ "license": "MIT",
+ "dependencies": {
+ "fill-range": "^7.1.1"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/buffer": {
+ "version": "5.7.1",
+ "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.7.1.tgz",
+ "integrity": "sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/feross"
+ },
+ {
+ "type": "patreon",
+ "url": "https://www.patreon.com/feross"
+ },
+ {
+ "type": "consulting",
+ "url": "https://feross.org/support"
+ }
+ ],
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "base64-js": "^1.3.1",
+ "ieee754": "^1.1.13"
+ }
+ },
+ "node_modules/buffer-crc32": {
+ "version": "0.2.13",
+ "resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz",
+ "integrity": "sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": "*"
+ }
+ },
+ "node_modules/buffer-from": {
+ "version": "1.1.2",
+ "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
+ "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/builder-util": {
+ "version": "26.8.1",
+ "resolved": "https://registry.npmjs.org/builder-util/-/builder-util-26.8.1.tgz",
+ "integrity": "sha512-pm1lTYbGyc90DHgCDO7eo8Rl4EqKLciayNbZqGziqnH9jrlKe8ZANGdityLZU+pJh16dfzjAx2xQq9McuIPEtw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/debug": "^4.1.6",
+ "7zip-bin": "~5.2.0",
+ "app-builder-bin": "5.0.0-alpha.12",
+ "builder-util-runtime": "9.5.1",
+ "chalk": "^4.1.2",
+ "cross-spawn": "^7.0.6",
+ "debug": "^4.3.4",
+ "fs-extra": "^10.1.0",
+ "http-proxy-agent": "^7.0.0",
+ "https-proxy-agent": "^7.0.0",
+ "js-yaml": "^4.1.0",
+ "sanitize-filename": "^1.6.3",
+ "source-map-support": "^0.5.19",
+ "stat-mode": "^1.0.0",
+ "temp-file": "^3.4.0",
+ "tiny-async-pool": "1.3.0"
+ }
+ },
+ "node_modules/builder-util-runtime": {
+ "version": "9.5.1",
+ "resolved": "https://registry.npmjs.org/builder-util-runtime/-/builder-util-runtime-9.5.1.tgz",
+ "integrity": "sha512-qt41tMfgHTllhResqM5DcnHyDIWNgzHvuY2jDcYP9iaGpkWxTUzV6GQjDeLnlR1/DtdlcsWQbA7sByMpmJFTLQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "debug": "^4.3.4",
+ "sax": "^1.2.4"
+ },
+ "engines": {
+ "node": ">=12.0.0"
+ }
+ },
+ "node_modules/builder-util/node_modules/fs-extra": {
+ "version": "10.1.0",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",
+ "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "graceful-fs": "^4.2.0",
+ "jsonfile": "^6.0.1",
+ "universalify": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/builder-util/node_modules/jsonfile": {
+ "version": "6.2.1",
+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz",
+ "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "universalify": "^2.0.0"
+ },
+ "optionalDependencies": {
+ "graceful-fs": "^4.1.6"
+ }
+ },
+ "node_modules/builder-util/node_modules/universalify": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+ "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 10.0.0"
+ }
+ },
+ "node_modules/cacheable-lookup": {
+ "version": "5.0.4",
+ "resolved": "https://registry.npmjs.org/cacheable-lookup/-/cacheable-lookup-5.0.4.tgz",
+ "integrity": "sha512-2/kNscPhpcxrOigMZzbiWF7dz8ilhb/nIHU3EyZiXWXpeq/au8qJ8VhdftMkty3n7Gj6HIGalQG8oiBNB3AJgA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=10.6.0"
+ }
+ },
+ "node_modules/cacheable-request": {
+ "version": "7.0.4",
+ "resolved": "https://registry.npmjs.org/cacheable-request/-/cacheable-request-7.0.4.tgz",
+ "integrity": "sha512-v+p6ongsrp0yTGbJXjgxPow2+DL93DASP4kXCDKb8/bwRtt9OEF3whggkkDkGNzgcWy2XaF4a8nZglC7uElscg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "clone-response": "^1.0.2",
+ "get-stream": "^5.1.0",
+ "http-cache-semantics": "^4.0.0",
+ "keyv": "^4.0.0",
+ "lowercase-keys": "^2.0.0",
+ "normalize-url": "^6.0.1",
+ "responselike": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/call-bind-apply-helpers": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+ "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "es-errors": "^1.3.0",
+ "function-bind": "^1.1.2"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/chalk": {
+ "version": "4.1.2",
+ "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+ "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "ansi-styles": "^4.1.0",
+ "supports-color": "^7.1.0"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/chalk/chalk?sponsor=1"
+ }
+ },
+ "node_modules/chokidar": {
+ "version": "3.6.0",
+ "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz",
+ "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==",
+ "license": "MIT",
+ "dependencies": {
+ "anymatch": "~3.1.2",
+ "braces": "~3.0.2",
+ "glob-parent": "~5.1.2",
+ "is-binary-path": "~2.1.0",
+ "is-glob": "~4.0.1",
+ "normalize-path": "~3.0.0",
+ "readdirp": "~3.6.0"
+ },
+ "engines": {
+ "node": ">= 8.10.0"
+ },
+ "funding": {
+ "url": "https://paulmillr.com/funding/"
+ },
+ "optionalDependencies": {
+ "fsevents": "~2.3.2"
+ }
+ },
+ "node_modules/chownr": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/chownr/-/chownr-3.0.0.tgz",
+ "integrity": "sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g==",
+ "dev": true,
+ "license": "BlueOak-1.0.0",
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/chromium-pickle-js": {
+ "version": "0.2.0",
+ "resolved": "https://registry.npmjs.org/chromium-pickle-js/-/chromium-pickle-js-0.2.0.tgz",
+ "integrity": "sha512-1R5Fho+jBq0DDydt+/vHWj5KJNJCKdARKOCwZUen84I5BreWoLqRLANH1U87eJy1tiASPtMnGqJJq0ZsLoRPOw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/ci-info": {
+ "version": "4.4.0",
+ "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-4.4.0.tgz",
+ "integrity": "sha512-77PSwercCZU2Fc4sX94eF8k8Pxte6JAwL4/ICZLFjJLqegs7kCuAsqqj/70NQF6TvDpgFjkubQB2FW2ZZddvQg==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/sibiraj-s"
+ }
+ ],
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/cli-truncate": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/cli-truncate/-/cli-truncate-2.1.0.tgz",
+ "integrity": "sha512-n8fOixwDD6b/ObinzTrp1ZKFzbgvKZvuz/TvejnLn1aQfC6r52XEx85FmuC+3HI+JM7coBRXUvNqEU2PHVrHpg==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "slice-ansi": "^3.0.0",
+ "string-width": "^4.2.0"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/cliui": {
+ "version": "8.0.1",
+ "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
+ "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "string-width": "^4.2.0",
+ "strip-ansi": "^6.0.1",
+ "wrap-ansi": "^7.0.0"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/clone-response": {
+ "version": "1.0.3",
+ "resolved": "https://registry.npmjs.org/clone-response/-/clone-response-1.0.3.tgz",
+ "integrity": "sha512-ROoL94jJH2dUVML2Y/5PEDNaSHgeOdSDicUyS7izcF63G6sTc/FTjLub4b8Il9S8S0beOfYt0TaA5qvFK+w0wA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "mimic-response": "^1.0.0"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/color-convert": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+ "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "color-name": "~1.1.4"
+ },
+ "engines": {
+ "node": ">=7.0.0"
+ }
+ },
+ "node_modules/color-name": {
+ "version": "1.1.4",
+ "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+ "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/combined-stream": {
+ "version": "1.0.8",
+ "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+ "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "delayed-stream": "~1.0.0"
+ },
+ "engines": {
+ "node": ">= 0.8"
+ }
+ },
+ "node_modules/commander": {
+ "version": "5.1.0",
+ "resolved": "https://registry.npmjs.org/commander/-/commander-5.1.0.tgz",
+ "integrity": "sha512-P0CysNDQ7rtVw4QIQtm+MRxV66vKFSvlsQvGYXZWR3qFU0jlMKHZZZgw8e+8DSah4UDKMqnknRDQz+xuQXQ/Zg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 6"
+ }
+ },
+ "node_modules/compare-version": {
+ "version": "0.1.2",
+ "resolved": "https://registry.npmjs.org/compare-version/-/compare-version-0.1.2.tgz",
+ "integrity": "sha512-pJDh5/4wrEnXX/VWRZvruAGHkzKdr46z11OlTPN+VrATlWWhSKewNCJ1futCO5C7eJB3nPMFZA1LeYtcFboZ2A==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/concat-map": {
+ "version": "0.0.1",
+ "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+ "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/core-util-is": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz",
+ "integrity": "sha512-3lqz5YjWTYnW6dlDa5TLaTCcShfar1e40rmcJVwCBJC6mWlFuj0eCHIElmG1g5kyuJ/GD+8Wn4FFCcz4gJPfaQ==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true
+ },
+ "node_modules/crc": {
+ "version": "3.8.0",
+ "resolved": "https://registry.npmjs.org/crc/-/crc-3.8.0.tgz",
+ "integrity": "sha512-iX3mfgcTMIq3ZKLIsVFAbv7+Mc10kxabAGQb8HvjA1o3T1PIYprbakQ65d3I+2HGHt6nSKkM9PYjgoJO2KcFBQ==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "buffer": "^5.1.0"
+ }
+ },
+ "node_modules/cross-dirname": {
+ "version": "0.1.0",
+ "resolved": "https://registry.npmjs.org/cross-dirname/-/cross-dirname-0.1.0.tgz",
+ "integrity": "sha512-+R08/oI0nl3vfPcqftZRpytksBXDzOUveBq/NBVx0sUp1axwzPQrKinNx5yd5sxPu8j1wIy8AfnVQ+5eFdha6Q==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "peer": true
+ },
+ "node_modules/cross-spawn": {
+ "version": "7.0.6",
+ "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+ "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "path-key": "^3.1.0",
+ "shebang-command": "^2.0.0",
+ "which": "^2.0.1"
+ },
+ "engines": {
+ "node": ">= 8"
+ }
+ },
+ "node_modules/cross-spawn-windows-exe": {
+ "version": "1.2.0",
+ "resolved": "https://registry.npmjs.org/cross-spawn-windows-exe/-/cross-spawn-windows-exe-1.2.0.tgz",
+ "integrity": "sha512-mkLtJJcYbDCxEG7Js6eUnUNndWjyUZwJ3H7bErmmtOYU/Zb99DyUkpamuIZE0b3bhmJyZ7D90uS6f+CGxRRjOw==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "individual",
+ "url": "https://github.com/sponsors/malept"
+ },
+ {
+ "type": "tidelift",
+ "url": "https://tidelift.com/subscription/pkg/npm-cross-spawn-windows-exe?utm_medium=referral&utm_source=npm_fund"
+ }
+ ],
+ "license": "Apache-2.0",
+ "dependencies": {
+ "@malept/cross-spawn-promise": "^1.1.0",
+ "is-wsl": "^2.2.0",
+ "which": "^2.0.2"
+ },
+ "engines": {
+ "node": ">= 10"
+ }
+ },
+ "node_modules/cross-spawn-windows-exe/node_modules/@malept/cross-spawn-promise": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/@malept/cross-spawn-promise/-/cross-spawn-promise-1.1.1.tgz",
+ "integrity": "sha512-RTBGWL5FWQcg9orDOCcp4LvItNzUPcyEU9bwaeJX0rJ1IQxzucC48Y0/sQLp/g6t99IQgAlGIaesJS+gTn7tVQ==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "individual",
+ "url": "https://github.com/sponsors/malept"
+ },
+ {
+ "type": "tidelift",
+ "url": "https://tidelift.com/subscription/pkg/npm-.malept-cross-spawn-promise?utm_medium=referral&utm_source=npm_fund"
+ }
+ ],
+ "license": "Apache-2.0",
+ "dependencies": {
+ "cross-spawn": "^7.0.1"
+ },
+ "engines": {
+ "node": ">= 10"
+ }
+ },
+ "node_modules/debug": {
+ "version": "4.4.3",
+ "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+ "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "ms": "^2.1.3"
+ },
+ "engines": {
+ "node": ">=6.0"
+ },
+ "peerDependenciesMeta": {
+ "supports-color": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/decompress-response": {
+ "version": "6.0.0",
+ "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-6.0.0.tgz",
+ "integrity": "sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "mimic-response": "^3.1.0"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/decompress-response/node_modules/mimic-response": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-3.1.0.tgz",
+ "integrity": "sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/deep-is": {
+ "version": "0.1.4",
+ "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
+ "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/defer-to-connect": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/defer-to-connect/-/defer-to-connect-2.0.1.tgz",
+ "integrity": "sha512-4tvttepXG1VaYGrRibk5EwJd1t4udunSOVMdLSAL6mId1ix438oPwPZMALY41FCijukO1L0twNcGsdzS7dHgDg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/define-data-property": {
+ "version": "1.1.4",
+ "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz",
+ "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "es-define-property": "^1.0.0",
+ "es-errors": "^1.3.0",
+ "gopd": "^1.0.1"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/define-properties": {
+ "version": "1.2.1",
+ "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.1.tgz",
+ "integrity": "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "define-data-property": "^1.0.1",
+ "has-property-descriptors": "^1.0.0",
+ "object-keys": "^1.1.1"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/delayed-stream": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+ "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.4.0"
+ }
+ },
+ "node_modules/detect-node": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/detect-node/-/detect-node-2.1.0.tgz",
+ "integrity": "sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true
+ },
+ "node_modules/dir-compare": {
+ "version": "4.2.0",
+ "resolved": "https://registry.npmjs.org/dir-compare/-/dir-compare-4.2.0.tgz",
+ "integrity": "sha512-2xMCmOoMrdQIPHdsTawECdNPwlVFB9zGcz3kuhmBO6U3oU+UQjsue0i8ayLKpgBcm+hcXPMVSGUN9d+pvJ6+VQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "minimatch": "^3.0.5",
+ "p-limit": "^3.1.0 "
+ }
+ },
+ "node_modules/dir-compare/node_modules/balanced-match": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+ "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/dir-compare/node_modules/brace-expansion": {
+ "version": "1.1.14",
+ "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.14.tgz",
+ "integrity": "sha512-MWPGfDxnyzKU7rNOW9SP/c50vi3xrmrua/+6hfPbCS2ABNWfx24vPidzvC7krjU/RTo235sV776ymlsMtGKj8g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "balanced-match": "^1.0.0",
+ "concat-map": "0.0.1"
+ }
+ },
+ "node_modules/dir-compare/node_modules/minimatch": {
+ "version": "3.1.5",
+ "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+ "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "brace-expansion": "^1.1.7"
+ },
+ "engines": {
+ "node": "*"
+ }
+ },
+ "node_modules/dmg-builder": {
+ "version": "26.8.1",
+ "resolved": "https://registry.npmjs.org/dmg-builder/-/dmg-builder-26.8.1.tgz",
+ "integrity": "sha512-glMJgnTreo8CFINujtAhCgN96QAqApDMZ8Vl1r8f0QT8QprvC1UCltV4CcWj20YoIyLZx6IUskaJZ0NV8fokcg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "app-builder-lib": "26.8.1",
+ "builder-util": "26.8.1",
+ "fs-extra": "^10.1.0",
+ "iconv-lite": "^0.6.2",
+ "js-yaml": "^4.1.0"
+ },
+ "optionalDependencies": {
+ "dmg-license": "^1.0.11"
+ }
+ },
+ "node_modules/dmg-builder/node_modules/fs-extra": {
+ "version": "10.1.0",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",
+ "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "graceful-fs": "^4.2.0",
+ "jsonfile": "^6.0.1",
+ "universalify": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/dmg-builder/node_modules/jsonfile": {
+ "version": "6.2.1",
+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz",
+ "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "universalify": "^2.0.0"
+ },
+ "optionalDependencies": {
+ "graceful-fs": "^4.1.6"
+ }
+ },
+ "node_modules/dmg-builder/node_modules/universalify": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+ "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 10.0.0"
+ }
+ },
+ "node_modules/dmg-license": {
+ "version": "1.0.11",
+ "resolved": "https://registry.npmjs.org/dmg-license/-/dmg-license-1.0.11.tgz",
+ "integrity": "sha512-ZdzmqwKmECOWJpqefloC5OJy1+WZBBse5+MR88z9g9Zn4VY+WYUkAyojmhzJckH5YbbZGcYIuGAkY5/Ys5OM2Q==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "dependencies": {
+ "@types/plist": "^3.0.1",
+ "@types/verror": "^1.10.3",
+ "ajv": "^6.10.0",
+ "crc": "^3.8.0",
+ "iconv-corefoundation": "^1.1.7",
+ "plist": "^3.0.4",
+ "smart-buffer": "^4.0.2",
+ "verror": "^1.10.0"
+ },
+ "bin": {
+ "dmg-license": "bin/dmg-license.js"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/dotenv": {
+ "version": "16.6.1",
+ "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.6.1.tgz",
+ "integrity": "sha512-uBq4egWHTcTt33a72vpSG0z3HnPuIl6NqYcTrKEg2azoEyl2hpW0zqlxysq2pK9HlDIHyHyakeYaYnSAwd8bow==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "engines": {
+ "node": ">=12"
+ },
+ "funding": {
+ "url": "https://dotenvx.com"
+ }
+ },
+ "node_modules/dotenv-expand": {
+ "version": "11.0.7",
+ "resolved": "https://registry.npmjs.org/dotenv-expand/-/dotenv-expand-11.0.7.tgz",
+ "integrity": "sha512-zIHwmZPRshsCdpMDyVsqGmgyP0yT8GAgXUnkdAoJisxvf33k7yO6OuoKmcTGuXPWSsm8Oh88nZicRLA9Y0rUeA==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "dependencies": {
+ "dotenv": "^16.4.5"
+ },
+ "engines": {
+ "node": ">=12"
+ },
+ "funding": {
+ "url": "https://dotenvx.com"
+ }
+ },
+ "node_modules/dunder-proto": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+ "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "call-bind-apply-helpers": "^1.0.1",
+ "es-errors": "^1.3.0",
+ "gopd": "^1.2.0"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/ejs": {
+ "version": "3.1.10",
+ "resolved": "https://registry.npmjs.org/ejs/-/ejs-3.1.10.tgz",
+ "integrity": "sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "dependencies": {
+ "jake": "^10.8.5"
+ },
+ "bin": {
+ "ejs": "bin/cli.js"
+ },
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/electron": {
+ "version": "41.3.0",
+ "resolved": "https://registry.npmjs.org/electron/-/electron-41.3.0.tgz",
+ "integrity": "sha512-2Q5aeocmFdeheZGDUTrAvSR3t+n0c3d104AJWWEnt7syJU0tE4VdibMYaPtQ47QuXSoUf0/xSsfUUvu/uSXIfg==",
+ "dev": true,
+ "hasInstallScript": true,
+ "license": "MIT",
+ "dependencies": {
+ "@electron/get": "^2.0.0",
+ "@types/node": "^24.9.0",
+ "extract-zip": "^2.0.1"
+ },
+ "bin": {
+ "electron": "cli.js"
+ },
+ "engines": {
+ "node": ">= 12.20.55"
+ }
+ },
+ "node_modules/electron-builder": {
+ "version": "26.8.1",
+ "resolved": "https://registry.npmjs.org/electron-builder/-/electron-builder-26.8.1.tgz",
+ "integrity": "sha512-uWhx1r74NGpCagG0ULs/P9Nqv2nsoo+7eo4fLUOB8L8MdWltq9odW/uuLXMFCDGnPafknYLZgjNX0ZIFRzOQAw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "app-builder-lib": "26.8.1",
+ "builder-util": "26.8.1",
+ "builder-util-runtime": "9.5.1",
+ "chalk": "^4.1.2",
+ "ci-info": "^4.2.0",
+ "dmg-builder": "26.8.1",
+ "fs-extra": "^10.1.0",
+ "lazy-val": "^1.0.5",
+ "simple-update-notifier": "2.0.0",
+ "yargs": "^17.6.2"
+ },
+ "bin": {
+ "electron-builder": "cli.js",
+ "install-app-deps": "install-app-deps.js"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ }
+ },
+ "node_modules/electron-builder-squirrel-windows": {
+ "version": "26.8.1",
+ "resolved": "https://registry.npmjs.org/electron-builder-squirrel-windows/-/electron-builder-squirrel-windows-26.8.1.tgz",
+ "integrity": "sha512-o288fIdgPLHA76eDrFADHPoo7VyGkDCYbLV1GzndaMSAVBoZrGvM9m2IehdcVMzdAZJ2eV9bgyissQXHv5tGzA==",
+ "dev": true,
+ "license": "MIT",
+ "peer": true,
+ "dependencies": {
+ "app-builder-lib": "26.8.1",
+ "builder-util": "26.8.1",
+ "electron-winstaller": "5.4.0"
+ }
+ },
+ "node_modules/electron-builder/node_modules/fs-extra": {
+ "version": "10.1.0",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",
+ "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "graceful-fs": "^4.2.0",
+ "jsonfile": "^6.0.1",
+ "universalify": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/electron-builder/node_modules/jsonfile": {
+ "version": "6.2.0",
+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz",
+ "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "universalify": "^2.0.0"
+ },
+ "optionalDependencies": {
+ "graceful-fs": "^4.1.6"
+ }
+ },
+ "node_modules/electron-builder/node_modules/universalify": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+ "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 10.0.0"
+ }
+ },
+ "node_modules/electron-publish": {
+ "version": "26.8.1",
+ "resolved": "https://registry.npmjs.org/electron-publish/-/electron-publish-26.8.1.tgz",
+ "integrity": "sha512-q+jrSTIh/Cv4eGZa7oVR+grEJo/FoLMYBAnSL5GCtqwUpr1T+VgKB/dn1pnzxIxqD8S/jP1yilT9VrwCqINR4w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/fs-extra": "^9.0.11",
+ "builder-util": "26.8.1",
+ "builder-util-runtime": "9.5.1",
+ "chalk": "^4.1.2",
+ "form-data": "^4.0.5",
+ "fs-extra": "^10.1.0",
+ "lazy-val": "^1.0.5",
+ "mime": "^2.5.2"
+ }
+ },
+ "node_modules/electron-publish/node_modules/fs-extra": {
+ "version": "10.1.0",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",
+ "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "graceful-fs": "^4.2.0",
+ "jsonfile": "^6.0.1",
+ "universalify": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/electron-publish/node_modules/jsonfile": {
+ "version": "6.2.1",
+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz",
+ "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "universalify": "^2.0.0"
+ },
+ "optionalDependencies": {
+ "graceful-fs": "^4.1.6"
+ }
+ },
+ "node_modules/electron-publish/node_modules/universalify": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+ "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 10.0.0"
+ }
+ },
+ "node_modules/electron-winstaller": {
+ "version": "5.4.0",
+ "resolved": "https://registry.npmjs.org/electron-winstaller/-/electron-winstaller-5.4.0.tgz",
+ "integrity": "sha512-bO3y10YikuUwUuDUQRM4KfwNkKhnpVO7IPdbsrejwN9/AABJzzTQ4GeHwyzNSrVO+tEH3/Np255a3sVZpZDjvg==",
+ "dev": true,
+ "hasInstallScript": true,
+ "license": "MIT",
+ "peer": true,
+ "dependencies": {
+ "@electron/asar": "^3.2.1",
+ "debug": "^4.1.1",
+ "fs-extra": "^7.0.1",
+ "lodash": "^4.17.21",
+ "temp": "^0.9.0"
+ },
+ "engines": {
+ "node": ">=8.0.0"
+ },
+ "optionalDependencies": {
+ "@electron/windows-sign": "^1.1.2"
+ }
+ },
+ "node_modules/electron-winstaller/node_modules/fs-extra": {
+ "version": "7.0.1",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-7.0.1.tgz",
+ "integrity": "sha512-YJDaCJZEnBmcbw13fvdAM9AwNOJwOzrE4pqMqBq5nFiEqXUqHwlK4B+3pUw6JNvfSPtX05xFHtYy/1ni01eGCw==",
+ "dev": true,
+ "license": "MIT",
+ "peer": true,
+ "dependencies": {
+ "graceful-fs": "^4.1.2",
+ "jsonfile": "^4.0.0",
+ "universalify": "^0.1.0"
+ },
+ "engines": {
+ "node": ">=6 <7 || >=8"
+ }
+ },
+ "node_modules/emoji-regex": {
+ "version": "8.0.0",
+ "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+ "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/end-of-stream": {
+ "version": "1.4.5",
+ "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.5.tgz",
+ "integrity": "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "once": "^1.4.0"
+ }
+ },
+ "node_modules/env-paths": {
+ "version": "2.2.1",
+ "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-2.2.1.tgz",
+ "integrity": "sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/err-code": {
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/err-code/-/err-code-2.0.3.tgz",
+ "integrity": "sha512-2bmlRpNKBxT/CRmPOlyISQpNj+qSeYvcym/uT0Jx2bMOlKLtSy1ZmLuVxSEKKyor/N5yhvp/ZiG1oE3DEYMSFA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/es-define-property": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+ "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/es-errors": {
+ "version": "1.3.0",
+ "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+ "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/es-object-atoms": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+ "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "es-errors": "^1.3.0"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/es-set-tostringtag": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+ "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "es-errors": "^1.3.0",
+ "get-intrinsic": "^1.2.6",
+ "has-tostringtag": "^1.0.2",
+ "hasown": "^2.0.2"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/es6-error": {
+ "version": "4.1.1",
+ "resolved": "https://registry.npmjs.org/es6-error/-/es6-error-4.1.1.tgz",
+ "integrity": "sha512-Um/+FxMr9CISWh0bi5Zv0iOD+4cFh5qLeks1qhAopKVAJw3drgKbKySikp7wGhDL0HPeaja0P5ULZrxLkniUVg==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true
+ },
+ "node_modules/escalade": {
+ "version": "3.2.0",
+ "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+ "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/escape-string-regexp": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+ "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/eslint": {
+ "version": "10.2.1",
+ "resolved": "https://registry.npmjs.org/eslint/-/eslint-10.2.1.tgz",
+ "integrity": "sha512-wiyGaKsDgqXvF40P8mDwiUp/KQjE1FdrIEJsM8PZ3XCiniTMXS3OHWWUe5FI5agoCnr8x4xPrTDZuxsBlNHl+Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@eslint-community/eslint-utils": "^4.8.0",
+ "@eslint-community/regexpp": "^4.12.2",
+ "@eslint/config-array": "^0.23.5",
+ "@eslint/config-helpers": "^0.5.5",
+ "@eslint/core": "^1.2.1",
+ "@eslint/plugin-kit": "^0.7.1",
+ "@humanfs/node": "^0.16.6",
+ "@humanwhocodes/module-importer": "^1.0.1",
+ "@humanwhocodes/retry": "^0.4.2",
+ "@types/estree": "^1.0.6",
+ "ajv": "^6.14.0",
+ "cross-spawn": "^7.0.6",
+ "debug": "^4.3.2",
+ "escape-string-regexp": "^4.0.0",
+ "eslint-scope": "^9.1.2",
+ "eslint-visitor-keys": "^5.0.1",
+ "espree": "^11.2.0",
+ "esquery": "^1.7.0",
+ "esutils": "^2.0.2",
+ "fast-deep-equal": "^3.1.3",
+ "file-entry-cache": "^8.0.0",
+ "find-up": "^5.0.0",
+ "glob-parent": "^6.0.2",
+ "ignore": "^5.2.0",
+ "imurmurhash": "^0.1.4",
+ "is-glob": "^4.0.0",
+ "json-stable-stringify-without-jsonify": "^1.0.1",
+ "minimatch": "^10.2.4",
+ "natural-compare": "^1.4.0",
+ "optionator": "^0.9.3"
+ },
+ "bin": {
+ "eslint": "bin/eslint.js"
+ },
+ "engines": {
+ "node": "^20.19.0 || ^22.13.0 || >=24"
+ },
+ "funding": {
+ "url": "https://eslint.org/donate"
+ },
+ "peerDependencies": {
+ "jiti": "*"
+ },
+ "peerDependenciesMeta": {
+ "jiti": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/eslint-plugin-security": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/eslint-plugin-security/-/eslint-plugin-security-4.0.0.tgz",
+ "integrity": "sha512-tfuQT8K/Li1ZxhFzyD8wPIKtlzZxqBcPr9q0jFMQ77wWAbKBVEhaMPVQRTMTvCMUDhwBe5vPVqQPwAGk/ASfxQ==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "dependencies": {
+ "safe-regex": "^2.1.1"
+ },
+ "engines": {
+ "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+ },
+ "funding": {
+ "url": "https://opencollective.com/eslint"
+ }
+ },
+ "node_modules/eslint-scope": {
+ "version": "9.1.2",
+ "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-9.1.2.tgz",
+ "integrity": "sha512-xS90H51cKw0jltxmvmHy2Iai1LIqrfbw57b79w/J7MfvDfkIkFZ+kj6zC3BjtUwh150HsSSdxXZcsuv72miDFQ==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "dependencies": {
+ "@types/esrecurse": "^4.3.1",
+ "@types/estree": "^1.0.8",
+ "esrecurse": "^4.3.0",
+ "estraverse": "^5.2.0"
+ },
+ "engines": {
+ "node": "^20.19.0 || ^22.13.0 || >=24"
+ },
+ "funding": {
+ "url": "https://opencollective.com/eslint"
+ }
+ },
+ "node_modules/eslint-visitor-keys": {
+ "version": "5.0.1",
+ "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-5.0.1.tgz",
+ "integrity": "sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "engines": {
+ "node": "^20.19.0 || ^22.13.0 || >=24"
+ },
+ "funding": {
+ "url": "https://opencollective.com/eslint"
+ }
+ },
+ "node_modules/eslint/node_modules/glob-parent": {
+ "version": "6.0.2",
+ "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
+ "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "is-glob": "^4.0.3"
+ },
+ "engines": {
+ "node": ">=10.13.0"
+ }
+ },
+ "node_modules/espree": {
+ "version": "11.2.0",
+ "resolved": "https://registry.npmjs.org/espree/-/espree-11.2.0.tgz",
+ "integrity": "sha512-7p3DrVEIopW1B1avAGLuCSh1jubc01H2JHc8B4qqGblmg5gI9yumBgACjWo4JlIc04ufug4xJ3SQI8HkS/Rgzw==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "dependencies": {
+ "acorn": "^8.16.0",
+ "acorn-jsx": "^5.3.2",
+ "eslint-visitor-keys": "^5.0.1"
+ },
+ "engines": {
+ "node": "^20.19.0 || ^22.13.0 || >=24"
+ },
+ "funding": {
+ "url": "https://opencollective.com/eslint"
+ }
+ },
+ "node_modules/esquery": {
+ "version": "1.7.0",
+ "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.7.0.tgz",
+ "integrity": "sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "dependencies": {
+ "estraverse": "^5.1.0"
+ },
+ "engines": {
+ "node": ">=0.10"
+ }
+ },
+ "node_modules/esrecurse": {
+ "version": "4.3.0",
+ "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz",
+ "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "dependencies": {
+ "estraverse": "^5.2.0"
+ },
+ "engines": {
+ "node": ">=4.0"
+ }
+ },
+ "node_modules/estraverse": {
+ "version": "5.3.0",
+ "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
+ "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "engines": {
+ "node": ">=4.0"
+ }
+ },
+ "node_modules/esutils": {
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
+ "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/exponential-backoff": {
+ "version": "3.1.3",
+ "resolved": "https://registry.npmjs.org/exponential-backoff/-/exponential-backoff-3.1.3.tgz",
+ "integrity": "sha512-ZgEeZXj30q+I0EN+CbSSpIyPaJ5HVQD18Z1m+u1FXbAeT94mr1zw50q4q6jiiC447Nl/YTcIYSAftiGqetwXCA==",
+ "dev": true,
+ "license": "Apache-2.0"
+ },
+ "node_modules/extract-zip": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/extract-zip/-/extract-zip-2.0.1.tgz",
+ "integrity": "sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "dependencies": {
+ "debug": "^4.1.1",
+ "get-stream": "^5.1.0",
+ "yauzl": "^2.10.0"
+ },
+ "bin": {
+ "extract-zip": "cli.js"
+ },
+ "engines": {
+ "node": ">= 10.17.0"
+ },
+ "optionalDependencies": {
+ "@types/yauzl": "^2.9.1"
+ }
+ },
+ "node_modules/extsprintf": {
+ "version": "1.4.1",
+ "resolved": "https://registry.npmjs.org/extsprintf/-/extsprintf-1.4.1.tgz",
+ "integrity": "sha512-Wrk35e8ydCKDj/ArClo1VrPVmN8zph5V4AtHwIuHhvMXsKf73UT3BOD+azBIW+3wOJ4FhEH7zyaJCFvChjYvMA==",
+ "dev": true,
+ "engines": [
+ "node >=0.6.0"
+ ],
+ "license": "MIT",
+ "optional": true
+ },
+ "node_modules/fast-deep-equal": {
+ "version": "3.1.3",
+ "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+ "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/fast-json-stable-stringify": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
+ "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/fast-levenshtein": {
+ "version": "2.0.6",
+ "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
+ "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/fd-slicer": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/fd-slicer/-/fd-slicer-1.1.0.tgz",
+ "integrity": "sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "pend": "~1.2.0"
+ }
+ },
+ "node_modules/file-entry-cache": {
+ "version": "8.0.0",
+ "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz",
+ "integrity": "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "flat-cache": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=16.0.0"
+ }
+ },
+ "node_modules/filelist": {
+ "version": "1.0.6",
+ "resolved": "https://registry.npmjs.org/filelist/-/filelist-1.0.6.tgz",
+ "integrity": "sha512-5giy2PkLYY1cP39p17Ech+2xlpTRL9HLspOfEgm0L6CwBXBTgsK5ou0JtzYuepxkaQ/tvhCFIJ5uXo0OrM2DxA==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "dependencies": {
+ "minimatch": "^5.0.1"
+ }
+ },
+ "node_modules/filelist/node_modules/balanced-match": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+ "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/filelist/node_modules/brace-expansion": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.0.tgz",
+ "integrity": "sha512-TN1kCZAgdgweJhWWpgKYrQaMNHcDULHkWwQIspdtjV4Y5aurRdZpjAqn6yX3FPqTA9ngHCc4hJxMAMgGfve85w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "balanced-match": "^1.0.0"
+ }
+ },
+ "node_modules/filelist/node_modules/minimatch": {
+ "version": "5.1.9",
+ "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.9.tgz",
+ "integrity": "sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "brace-expansion": "^2.0.1"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/fill-range": {
+ "version": "7.1.1",
+ "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
+ "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
+ "license": "MIT",
+ "dependencies": {
+ "to-regex-range": "^5.0.1"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/find-up": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
+ "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "locate-path": "^6.0.0",
+ "path-exists": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/flat-cache": {
+ "version": "4.0.1",
+ "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-4.0.1.tgz",
+ "integrity": "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "flatted": "^3.2.9",
+ "keyv": "^4.5.4"
+ },
+ "engines": {
+ "node": ">=16"
+ }
+ },
+ "node_modules/flatted": {
+ "version": "3.4.2",
+ "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.4.2.tgz",
+ "integrity": "sha512-PjDse7RzhcPkIJwy5t7KPWQSZ9cAbzQXcafsetQoD7sOJRQlGikNbx7yZp2OotDnJyrDcbyRq3Ttb18iYOqkxA==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/form-data": {
+ "version": "4.0.5",
+ "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz",
+ "integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "asynckit": "^0.4.0",
+ "combined-stream": "^1.0.8",
+ "es-set-tostringtag": "^2.1.0",
+ "hasown": "^2.0.2",
+ "mime-types": "^2.1.12"
+ },
+ "engines": {
+ "node": ">= 6"
+ }
+ },
+ "node_modules/fs-extra": {
+ "version": "8.1.0",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-8.1.0.tgz",
+ "integrity": "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "graceful-fs": "^4.2.0",
+ "jsonfile": "^4.0.0",
+ "universalify": "^0.1.0"
+ },
+ "engines": {
+ "node": ">=6 <7 || >=8"
+ }
+ },
+ "node_modules/fs.realpath": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+ "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/fsevents": {
+ "version": "2.3.3",
+ "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+ "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+ "hasInstallScript": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "engines": {
+ "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+ }
+ },
+ "node_modules/function-bind": {
+ "version": "1.1.2",
+ "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+ "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+ "dev": true,
+ "license": "MIT",
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/get-caller-file": {
+ "version": "2.0.5",
+ "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
+ "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
+ "dev": true,
+ "license": "ISC",
+ "engines": {
+ "node": "6.* || 8.* || >= 10.*"
+ }
+ },
+ "node_modules/get-intrinsic": {
+ "version": "1.3.0",
+ "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+ "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "call-bind-apply-helpers": "^1.0.2",
+ "es-define-property": "^1.0.1",
+ "es-errors": "^1.3.0",
+ "es-object-atoms": "^1.1.1",
+ "function-bind": "^1.1.2",
+ "get-proto": "^1.0.1",
+ "gopd": "^1.2.0",
+ "has-symbols": "^1.1.0",
+ "hasown": "^2.0.2",
+ "math-intrinsics": "^1.1.0"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/get-proto": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+ "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "dunder-proto": "^1.0.1",
+ "es-object-atoms": "^1.0.0"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/get-stream": {
+ "version": "5.2.0",
+ "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-5.2.0.tgz",
+ "integrity": "sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "pump": "^3.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/glob": {
+ "version": "7.2.3",
+ "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
+ "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
+ "deprecated": "Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "fs.realpath": "^1.0.0",
+ "inflight": "^1.0.4",
+ "inherits": "2",
+ "minimatch": "^3.1.1",
+ "once": "^1.3.0",
+ "path-is-absolute": "^1.0.0"
+ },
+ "engines": {
+ "node": "*"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/isaacs"
+ }
+ },
+ "node_modules/glob-parent": {
+ "version": "5.1.2",
+ "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+ "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+ "license": "ISC",
+ "dependencies": {
+ "is-glob": "^4.0.1"
+ },
+ "engines": {
+ "node": ">= 6"
+ }
+ },
+ "node_modules/glob/node_modules/balanced-match": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+ "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/glob/node_modules/brace-expansion": {
+ "version": "1.1.14",
+ "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.14.tgz",
+ "integrity": "sha512-MWPGfDxnyzKU7rNOW9SP/c50vi3xrmrua/+6hfPbCS2ABNWfx24vPidzvC7krjU/RTo235sV776ymlsMtGKj8g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "balanced-match": "^1.0.0",
+ "concat-map": "0.0.1"
+ }
+ },
+ "node_modules/glob/node_modules/minimatch": {
+ "version": "3.1.5",
+ "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+ "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "brace-expansion": "^1.1.7"
+ },
+ "engines": {
+ "node": "*"
+ }
+ },
+ "node_modules/global-agent": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/global-agent/-/global-agent-3.0.0.tgz",
+ "integrity": "sha512-PT6XReJ+D07JvGoxQMkT6qji/jVNfX/h364XHZOWeRzy64sSFr+xJ5OX7LI3b4MPQzdL4H8Y8M0xzPpsVMwA8Q==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "optional": true,
+ "dependencies": {
+ "boolean": "^3.0.1",
+ "es6-error": "^4.1.1",
+ "matcher": "^3.0.0",
+ "roarr": "^2.15.3",
+ "semver": "^7.3.2",
+ "serialize-error": "^7.0.1"
+ },
+ "engines": {
+ "node": ">=10.0"
+ }
+ },
+ "node_modules/global-agent/node_modules/semver": {
+ "version": "7.7.4",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
+ "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+ "dev": true,
+ "license": "ISC",
+ "optional": true,
+ "bin": {
+ "semver": "bin/semver.js"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/globalthis": {
+ "version": "1.0.4",
+ "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.4.tgz",
+ "integrity": "sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "define-properties": "^1.2.1",
+ "gopd": "^1.0.1"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/gopd": {
+ "version": "1.2.0",
+ "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+ "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/got": {
+ "version": "11.8.6",
+ "resolved": "https://registry.npmjs.org/got/-/got-11.8.6.tgz",
+ "integrity": "sha512-6tfZ91bOr7bOXnK7PRDCGBLa1H4U080YHNaAQ2KsMGlLEzRbk44nsZF2E1IeRc3vtJHPVbKCYgdFbaGO2ljd8g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@sindresorhus/is": "^4.0.0",
+ "@szmarczak/http-timer": "^4.0.5",
+ "@types/cacheable-request": "^6.0.1",
+ "@types/responselike": "^1.0.0",
+ "cacheable-lookup": "^5.0.3",
+ "cacheable-request": "^7.0.2",
+ "decompress-response": "^6.0.0",
+ "http2-wrapper": "^1.0.0-beta.5.2",
+ "lowercase-keys": "^2.0.0",
+ "p-cancelable": "^2.0.0",
+ "responselike": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=10.19.0"
+ },
+ "funding": {
+ "url": "https://github.com/sindresorhus/got?sponsor=1"
+ }
+ },
+ "node_modules/graceful-fs": {
+ "version": "4.2.11",
+ "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
+ "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/has-flag": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+ "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/has-property-descriptors": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz",
+ "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "es-define-property": "^1.0.0"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/has-symbols": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+ "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/has-tostringtag": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
+ "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "has-symbols": "^1.0.3"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/hasown": {
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.3.tgz",
+ "integrity": "sha512-ej4AhfhfL2Q2zpMmLo7U1Uv9+PyhIZpgQLGT1F9miIGmiCJIoCgSmczFdrc97mWT4kVY72KA+WnnhJ5pghSvSg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "function-bind": "^1.1.2"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/hosted-git-info": {
+ "version": "4.1.0",
+ "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-4.1.0.tgz",
+ "integrity": "sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "lru-cache": "^6.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/http-cache-semantics": {
+ "version": "4.2.0",
+ "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz",
+ "integrity": "sha512-dTxcvPXqPvXBQpq5dUr6mEMJX4oIEFv6bwom3FDwKRDsuIjjJGANqhBuoAn9c1RQJIdAKav33ED65E2ys+87QQ==",
+ "dev": true,
+ "license": "BSD-2-Clause"
+ },
+ "node_modules/http-proxy-agent": {
+ "version": "7.0.2",
+ "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz",
+ "integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "agent-base": "^7.1.0",
+ "debug": "^4.3.4"
+ },
+ "engines": {
+ "node": ">= 14"
+ }
+ },
+ "node_modules/http2-wrapper": {
+ "version": "1.0.3",
+ "resolved": "https://registry.npmjs.org/http2-wrapper/-/http2-wrapper-1.0.3.tgz",
+ "integrity": "sha512-V+23sDMr12Wnz7iTcDeJr3O6AIxlnvT/bmaAAAP/Xda35C90p9599p0F1eHR/N1KILWSoWVAiOMFjBBXaXSMxg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "quick-lru": "^5.1.1",
+ "resolve-alpn": "^1.0.0"
+ },
+ "engines": {
+ "node": ">=10.19.0"
+ }
+ },
+ "node_modules/https-proxy-agent": {
+ "version": "7.0.6",
+ "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
+ "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "agent-base": "^7.1.2",
+ "debug": "4"
+ },
+ "engines": {
+ "node": ">= 14"
+ }
+ },
+ "node_modules/iconv-corefoundation": {
+ "version": "1.1.7",
+ "resolved": "https://registry.npmjs.org/iconv-corefoundation/-/iconv-corefoundation-1.1.7.tgz",
+ "integrity": "sha512-T10qvkw0zz4wnm560lOEg0PovVqUXuOFhhHAkixw8/sycy7TJt7v/RrkEKEQnAw2viPSJu6iAkErxnzR0g8PpQ==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "dependencies": {
+ "cli-truncate": "^2.1.0",
+ "node-addon-api": "^1.6.3"
+ },
+ "engines": {
+ "node": "^8.11.2 || >=10"
+ }
+ },
+ "node_modules/iconv-lite": {
+ "version": "0.6.3",
+ "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz",
+ "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "safer-buffer": ">= 2.1.2 < 3.0.0"
+ },
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/ieee754": {
+ "version": "1.2.1",
+ "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
+ "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/feross"
+ },
+ {
+ "type": "patreon",
+ "url": "https://www.patreon.com/feross"
+ },
+ {
+ "type": "consulting",
+ "url": "https://feross.org/support"
+ }
+ ],
+ "license": "BSD-3-Clause",
+ "optional": true
+ },
+ "node_modules/ignore": {
+ "version": "5.3.2",
+ "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
+ "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 4"
+ }
+ },
+ "node_modules/imurmurhash": {
+ "version": "0.1.4",
+ "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
+ "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.8.19"
+ }
+ },
+ "node_modules/inflight": {
+ "version": "1.0.6",
+ "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+ "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
+ "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "once": "^1.3.0",
+ "wrappy": "1"
+ }
+ },
+ "node_modules/inherits": {
+ "version": "2.0.4",
+ "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+ "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/is-binary-path": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
+ "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
+ "license": "MIT",
+ "dependencies": {
+ "binary-extensions": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/is-docker": {
+ "version": "2.2.1",
+ "resolved": "https://registry.npmjs.org/is-docker/-/is-docker-2.2.1.tgz",
+ "integrity": "sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==",
+ "dev": true,
+ "license": "MIT",
+ "bin": {
+ "is-docker": "cli.js"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/is-extglob": {
+ "version": "2.1.1",
+ "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+ "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/is-fullwidth-code-point": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+ "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/is-glob": {
+ "version": "4.0.3",
+ "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+ "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+ "license": "MIT",
+ "dependencies": {
+ "is-extglob": "^2.1.1"
+ },
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/is-number": {
+ "version": "7.0.0",
+ "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+ "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.12.0"
+ }
+ },
+ "node_modules/is-wsl": {
+ "version": "2.2.0",
+ "resolved": "https://registry.npmjs.org/is-wsl/-/is-wsl-2.2.0.tgz",
+ "integrity": "sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "is-docker": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/isbinaryfile": {
+ "version": "5.0.7",
+ "resolved": "https://registry.npmjs.org/isbinaryfile/-/isbinaryfile-5.0.7.tgz",
+ "integrity": "sha512-gnWD14Jh3FzS3CPhF0AxNOJ8CxqeblPTADzI38r0wt8ZyQl5edpy75myt08EG2oKvpyiqSqsx+Wkz9vtkbTqYQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 18.0.0"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/gjtorikian/"
+ }
+ },
+ "node_modules/isexe": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+ "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/jake": {
+ "version": "10.9.4",
+ "resolved": "https://registry.npmjs.org/jake/-/jake-10.9.4.tgz",
+ "integrity": "sha512-wpHYzhxiVQL+IV05BLE2Xn34zW1S223hvjtqk0+gsPrwd/8JNLXJgZZM/iPFsYc1xyphF+6M6EvdE5E9MBGkDA==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "dependencies": {
+ "async": "^3.2.6",
+ "filelist": "^1.0.4",
+ "picocolors": "^1.1.1"
+ },
+ "bin": {
+ "jake": "bin/cli.js"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/jiti": {
+ "version": "2.6.1",
+ "resolved": "https://registry.npmjs.org/jiti/-/jiti-2.6.1.tgz",
+ "integrity": "sha512-ekilCSN1jwRvIbgeg/57YFh8qQDNbwDb9xT/qu2DAHbFFZUicIl4ygVaAvzveMhMVr3LnpSKTNnwt8PoOfmKhQ==",
+ "dev": true,
+ "license": "MIT",
+ "bin": {
+ "jiti": "lib/jiti-cli.mjs"
+ }
+ },
+ "node_modules/js-yaml": {
+ "version": "4.1.1",
+ "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
+ "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "argparse": "^2.0.1"
+ },
+ "bin": {
+ "js-yaml": "bin/js-yaml.js"
+ }
+ },
+ "node_modules/json-buffer": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
+ "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/json-schema-traverse": {
+ "version": "0.4.1",
+ "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+ "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/json-stable-stringify-without-jsonify": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
+ "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/json-stringify-safe": {
+ "version": "5.0.1",
+ "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz",
+ "integrity": "sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==",
+ "dev": true,
+ "license": "ISC",
+ "optional": true
+ },
+ "node_modules/json5": {
+ "version": "2.2.3",
+ "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+ "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+ "dev": true,
+ "license": "MIT",
+ "bin": {
+ "json5": "lib/cli.js"
+ },
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/jsonfile": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-4.0.0.tgz",
+ "integrity": "sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==",
+ "dev": true,
+ "license": "MIT",
+ "optionalDependencies": {
+ "graceful-fs": "^4.1.6"
+ }
+ },
+ "node_modules/keyv": {
+ "version": "4.5.4",
+ "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
+ "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "json-buffer": "3.0.1"
+ }
+ },
+ "node_modules/lazy-val": {
+ "version": "1.0.5",
+ "resolved": "https://registry.npmjs.org/lazy-val/-/lazy-val-1.0.5.tgz",
+ "integrity": "sha512-0/BnGCCfyUMkBpeDgWihanIAF9JmZhHBgUhEqzvf+adhNGLoP6TaiI5oF8oyb3I45P+PcnrqihSf01M0l0G5+Q==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/levn": {
+ "version": "0.4.1",
+ "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
+ "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "prelude-ls": "^1.2.1",
+ "type-check": "~0.4.0"
+ },
+ "engines": {
+ "node": ">= 0.8.0"
+ }
+ },
+ "node_modules/locate-path": {
+ "version": "6.0.0",
+ "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
+ "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "p-locate": "^5.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/lodash": {
+ "version": "4.18.1",
+ "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.18.1.tgz",
+ "integrity": "sha512-dMInicTPVE8d1e5otfwmmjlxkZoUpiVLwyeTdUsi/Caj/gfzzblBcCE5sRHV/AsjuCmxWrte2TNGSYuCeCq+0Q==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/lowercase-keys": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-2.0.0.tgz",
+ "integrity": "sha512-tqNXrS78oMOE73NMxK4EMLQsQowWf8jKooH9g7xPavRT706R6bkQJ6DY2Te7QukaZsulxa30wQ7bk0pm4XiHmA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/lru-cache": {
+ "version": "6.0.0",
+ "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz",
+ "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "yallist": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/matcher": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/matcher/-/matcher-3.0.0.tgz",
+ "integrity": "sha512-OkeDaAZ/bQCxeFAozM55PKcKU0yJMPGifLwV4Qgjitu+5MoAfSQN4lsLJeXZ1b8w0x+/Emda6MZgXS1jvsapng==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "escape-string-regexp": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/math-intrinsics": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+ "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/mime": {
+ "version": "2.6.0",
+ "resolved": "https://registry.npmjs.org/mime/-/mime-2.6.0.tgz",
+ "integrity": "sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg==",
+ "dev": true,
+ "license": "MIT",
+ "bin": {
+ "mime": "cli.js"
+ },
+ "engines": {
+ "node": ">=4.0.0"
+ }
+ },
+ "node_modules/mime-db": {
+ "version": "1.52.0",
+ "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+ "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.6"
+ }
+ },
+ "node_modules/mime-types": {
+ "version": "2.1.35",
+ "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+ "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "mime-db": "1.52.0"
+ },
+ "engines": {
+ "node": ">= 0.6"
+ }
+ },
+ "node_modules/mimic-response": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-1.0.1.tgz",
+ "integrity": "sha512-j5EctnkH7amfV/q5Hgmoal1g2QHFJRraOtmx0JpIqkxhBhI/lJSl1nMpQ45hVarwNETOoWEimndZ4QK0RHxuxQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=4"
+ }
+ },
+ "node_modules/minimatch": {
+ "version": "10.2.4",
+ "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.4.tgz",
+ "integrity": "sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg==",
+ "dev": true,
+ "license": "BlueOak-1.0.0",
+ "dependencies": {
+ "brace-expansion": "^5.0.2"
+ },
+ "engines": {
+ "node": "18 || 20 || >=22"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/isaacs"
+ }
+ },
+ "node_modules/minimist": {
+ "version": "1.2.8",
+ "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
+ "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
+ "dev": true,
+ "license": "MIT",
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/minipass": {
+ "version": "7.1.3",
+ "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz",
+ "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==",
+ "dev": true,
+ "license": "BlueOak-1.0.0",
+ "engines": {
+ "node": ">=16 || 14 >=14.17"
+ }
+ },
+ "node_modules/minizlib": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-3.1.0.tgz",
+ "integrity": "sha512-KZxYo1BUkWD2TVFLr0MQoM8vUUigWD3LlD83a/75BqC+4qE0Hb1Vo5v1FgcfaNXvfXzr+5EhQ6ing/CaBijTlw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "minipass": "^7.1.2"
+ },
+ "engines": {
+ "node": ">= 18"
+ }
+ },
+ "node_modules/mkdirp": {
+ "version": "0.5.6",
+ "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.6.tgz",
+ "integrity": "sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==",
+ "dev": true,
+ "license": "MIT",
+ "peer": true,
+ "dependencies": {
+ "minimist": "^1.2.6"
+ },
+ "bin": {
+ "mkdirp": "bin/cmd.js"
+ }
+ },
+ "node_modules/ms": {
+ "version": "2.1.3",
+ "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+ "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/natural-compare": {
+ "version": "1.4.0",
+ "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
+ "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/node-abi": {
+ "version": "4.28.0",
+ "resolved": "https://registry.npmjs.org/node-abi/-/node-abi-4.28.0.tgz",
+ "integrity": "sha512-Qfp5XZL1cJDOabOT8H5gnqMTmM4NjvYzHp4I/Kt/Sl76OVkOBBHRFlPspGV0hYvMoqQsypFjT/Yp7Km0beXW9g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "semver": "^7.6.3"
+ },
+ "engines": {
+ "node": ">=22.12.0"
+ }
+ },
+ "node_modules/node-abi/node_modules/semver": {
+ "version": "7.7.4",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
+ "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+ "dev": true,
+ "license": "ISC",
+ "bin": {
+ "semver": "bin/semver.js"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/node-addon-api": {
+ "version": "1.7.2",
+ "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-1.7.2.tgz",
+ "integrity": "sha512-ibPK3iA+vaY1eEjESkQkM0BbCqFOaZMiXRTtdB0u7b4djtY6JnsjvPdUHVMg6xQt3B8fpTTWHI9A+ADjM9frzg==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true
+ },
+ "node_modules/node-api-version": {
+ "version": "0.2.1",
+ "resolved": "https://registry.npmjs.org/node-api-version/-/node-api-version-0.2.1.tgz",
+ "integrity": "sha512-2xP/IGGMmmSQpI1+O/k72jF/ykvZ89JeuKX3TLJAYPDVLUalrshrLHkeVcCCZqG/eEa635cr8IBYzgnDvM2O8Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "semver": "^7.3.5"
+ }
+ },
+ "node_modules/node-api-version/node_modules/semver": {
+ "version": "7.7.4",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
+ "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+ "dev": true,
+ "license": "ISC",
+ "bin": {
+ "semver": "bin/semver.js"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/node-gyp": {
+ "version": "12.3.0",
+ "resolved": "https://registry.npmjs.org/node-gyp/-/node-gyp-12.3.0.tgz",
+ "integrity": "sha512-QNcUWM+HgJplcPzBvFBZ9VXacyGZ4+VTOb80PwWR+TlVzoHbRKULNEzpRsnaoxG3Wzr7Qh7BYxGDU3CbKib2Yg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "env-paths": "^2.2.0",
+ "exponential-backoff": "^3.1.1",
+ "graceful-fs": "^4.2.6",
+ "nopt": "^9.0.0",
+ "proc-log": "^6.0.0",
+ "semver": "^7.3.5",
+ "tar": "^7.5.4",
+ "tinyglobby": "^0.2.12",
+ "undici": "^6.25.0",
+ "which": "^6.0.0"
+ },
+ "bin": {
+ "node-gyp": "bin/node-gyp.js"
+ },
+ "engines": {
+ "node": "^20.17.0 || >=22.9.0"
+ }
+ },
+ "node_modules/node-gyp/node_modules/isexe": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/isexe/-/isexe-4.0.0.tgz",
+ "integrity": "sha512-FFUtZMpoZ8RqHS3XeXEmHWLA4thH+ZxCv2lOiPIn1Xc7CxrqhWzNSDzD+/chS/zbYezmiwWLdQC09JdQKmthOw==",
+ "dev": true,
+ "license": "BlueOak-1.0.0",
+ "engines": {
+ "node": ">=20"
+ }
+ },
+ "node_modules/node-gyp/node_modules/semver": {
+ "version": "7.7.4",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
+ "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+ "dev": true,
+ "license": "ISC",
+ "bin": {
+ "semver": "bin/semver.js"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/node-gyp/node_modules/undici": {
+ "version": "6.25.0",
+ "resolved": "https://registry.npmjs.org/undici/-/undici-6.25.0.tgz",
+ "integrity": "sha512-ZgpWDC5gmNiuY9CnLVXEH8rl50xhRCuLNA97fAUnKi8RRuV4E6KG31pDTsLVUKnohJE0I3XDrTeEydAXRw47xg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=18.17"
+ }
+ },
+ "node_modules/node-gyp/node_modules/which": {
+ "version": "6.0.1",
+ "resolved": "https://registry.npmjs.org/which/-/which-6.0.1.tgz",
+ "integrity": "sha512-oGLe46MIrCRqX7ytPUf66EAYvdeMIZYn3WaocqqKZAxrBpkqHfL/qvTyJ/bTk5+AqHCjXmrv3CEWgy368zhRUg==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "isexe": "^4.0.0"
+ },
+ "bin": {
+ "node-which": "bin/which.js"
+ },
+ "engines": {
+ "node": "^20.17.0 || >=22.9.0"
+ }
+ },
+ "node_modules/nopt": {
+ "version": "9.0.0",
+ "resolved": "https://registry.npmjs.org/nopt/-/nopt-9.0.0.tgz",
+ "integrity": "sha512-Zhq3a+yFKrYwSBluL4H9XP3m3y5uvQkB/09CwDruCiRmR/UJYnn9W4R48ry0uGC70aeTPKLynBtscP9efFFcPw==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "abbrev": "^4.0.0"
+ },
+ "bin": {
+ "nopt": "bin/nopt.js"
+ },
+ "engines": {
+ "node": "^20.17.0 || >=22.9.0"
+ }
+ },
+ "node_modules/normalize-path": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+ "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/normalize-url": {
+ "version": "6.1.0",
+ "resolved": "https://registry.npmjs.org/normalize-url/-/normalize-url-6.1.0.tgz",
+ "integrity": "sha512-DlL+XwOy3NxAQ8xuC0okPgK46iuVNAK01YN7RueYBqqFeGsBjV9XmCAzAdgt+667bCl5kPh9EqKKDwnaPG1I7A==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/object-keys": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz",
+ "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/once": {
+ "version": "1.4.0",
+ "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+ "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "wrappy": "1"
+ }
+ },
+ "node_modules/optionator": {
+ "version": "0.9.4",
+ "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
+ "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "deep-is": "^0.1.3",
+ "fast-levenshtein": "^2.0.6",
+ "levn": "^0.4.1",
+ "prelude-ls": "^1.2.1",
+ "type-check": "^0.4.0",
+ "word-wrap": "^1.2.5"
+ },
+ "engines": {
+ "node": ">= 0.8.0"
+ }
+ },
+ "node_modules/p-cancelable": {
+ "version": "2.1.1",
+ "resolved": "https://registry.npmjs.org/p-cancelable/-/p-cancelable-2.1.1.tgz",
+ "integrity": "sha512-BZOr3nRQHOntUjTrH8+Lh54smKHoHyur8We1V8DSMVrl5A2malOOwuJRnKRDjSnkoeBh4at6BwEnb5I7Jl31wg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/p-limit": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
+ "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "yocto-queue": "^0.1.0"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/p-locate": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
+ "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "p-limit": "^3.0.2"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/path-exists": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
+ "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/path-is-absolute": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
+ "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/path-key": {
+ "version": "3.1.1",
+ "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+ "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/pe-library": {
+ "version": "0.4.1",
+ "resolved": "https://registry.npmjs.org/pe-library/-/pe-library-0.4.1.tgz",
+ "integrity": "sha512-eRWB5LBz7PpDu4PUlwT0PhnQfTQJlDDdPa35urV4Osrm0t0AqQFGn+UIkU3klZvwJ8KPO3VbBFsXquA6p6kqZw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=12",
+ "npm": ">=6"
+ },
+ "funding": {
+ "type": "github",
+ "url": "https://github.com/sponsors/jet2jet"
+ }
+ },
+ "node_modules/pend": {
+ "version": "1.2.0",
+ "resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz",
+ "integrity": "sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/picocolors": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+ "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/picomatch": {
+ "version": "2.3.2",
+ "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.2.tgz",
+ "integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=8.6"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/jonschlinkert"
+ }
+ },
+ "node_modules/plist": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/plist/-/plist-3.1.0.tgz",
+ "integrity": "sha512-uysumyrvkUX0rX/dEVqt8gC3sTBzd4zoWfLeS29nb53imdaXVvLINYXTI2GNqzaMuvacNx4uJQ8+b3zXR0pkgQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@xmldom/xmldom": "^0.8.8",
+ "base64-js": "^1.5.1",
+ "xmlbuilder": "^15.1.1"
+ },
+ "engines": {
+ "node": ">=10.4.0"
+ }
+ },
+ "node_modules/postject": {
+ "version": "1.0.0-alpha.6",
+ "resolved": "https://registry.npmjs.org/postject/-/postject-1.0.0-alpha.6.tgz",
+ "integrity": "sha512-b9Eb8h2eVqNE8edvKdwqkrY6O7kAwmI8kcnBv1NScolYJbo59XUF0noFq+lxbC1yN20bmC0WBEbDC5H/7ASb0A==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "peer": true,
+ "dependencies": {
+ "commander": "^9.4.0"
+ },
+ "bin": {
+ "postject": "dist/cli.js"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ }
+ },
+ "node_modules/postject/node_modules/commander": {
+ "version": "9.5.0",
+ "resolved": "https://registry.npmjs.org/commander/-/commander-9.5.0.tgz",
+ "integrity": "sha512-KRs7WVDKg86PWiuAqhDrAQnTXZKraVcCc6vFdL14qrZ/DcWwuRo7VoiYXalXO7S5GKpqYiVEwCbgFDfxNHKJBQ==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "peer": true,
+ "engines": {
+ "node": "^12.20.0 || >=14"
+ }
+ },
+ "node_modules/prelude-ls": {
+ "version": "1.2.1",
+ "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
+ "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.8.0"
+ }
+ },
+ "node_modules/proc-log": {
+ "version": "6.1.0",
+ "resolved": "https://registry.npmjs.org/proc-log/-/proc-log-6.1.0.tgz",
+ "integrity": "sha512-iG+GYldRf2BQ0UDUAd6JQ/RwzaQy6mXmsk/IzlYyal4A4SNFw54MeH4/tLkF4I5WoWG9SQwuqWzS99jaFQHBuQ==",
+ "dev": true,
+ "license": "ISC",
+ "engines": {
+ "node": "^20.17.0 || >=22.9.0"
+ }
+ },
+ "node_modules/progress": {
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz",
+ "integrity": "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.4.0"
+ }
+ },
+ "node_modules/promise-retry": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/promise-retry/-/promise-retry-2.0.1.tgz",
+ "integrity": "sha512-y+WKFlBR8BGXnsNlIHFGPZmyDf3DFMoLhaflAnyZgV6rG6xu+JwesTo2Q9R6XwYmtmwAFCkAk3e35jEdoeh/3g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "err-code": "^2.0.2",
+ "retry": "^0.12.0"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/proper-lockfile": {
+ "version": "4.1.2",
+ "resolved": "https://registry.npmjs.org/proper-lockfile/-/proper-lockfile-4.1.2.tgz",
+ "integrity": "sha512-TjNPblN4BwAWMXU8s9AEz4JmQxnD1NNL7bNOY/AKUzyamc379FWASUhc/K1pL2noVb+XmZKLL68cjzLsiOAMaA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "graceful-fs": "^4.2.4",
+ "retry": "^0.12.0",
+ "signal-exit": "^3.0.2"
+ }
+ },
+ "node_modules/pump": {
+ "version": "3.0.3",
+ "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.3.tgz",
+ "integrity": "sha512-todwxLMY7/heScKmntwQG8CXVkWUOdYxIvY2s0VWAAMh/nd8SoYiRaKjlr7+iCs984f2P8zvrfWcDDYVb73NfA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "end-of-stream": "^1.1.0",
+ "once": "^1.3.1"
+ }
+ },
+ "node_modules/punycode": {
+ "version": "2.3.1",
+ "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
+ "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/quick-lru": {
+ "version": "5.1.1",
+ "resolved": "https://registry.npmjs.org/quick-lru/-/quick-lru-5.1.1.tgz",
+ "integrity": "sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/rcedit": {
+ "version": "4.0.1",
+ "resolved": "https://registry.npmjs.org/rcedit/-/rcedit-4.0.1.tgz",
+ "integrity": "sha512-bZdaQi34krFWhrDn+O53ccBDw0MkAT2Vhu75SqhtvhQu4OPyFM4RoVheyYiVQYdjhUi6EJMVWQ0tR6bCIYVkUg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "cross-spawn-windows-exe": "^1.1.0"
+ },
+ "engines": {
+ "node": ">= 14.0.0"
+ }
+ },
+ "node_modules/read-binary-file-arch": {
+ "version": "1.0.6",
+ "resolved": "https://registry.npmjs.org/read-binary-file-arch/-/read-binary-file-arch-1.0.6.tgz",
+ "integrity": "sha512-BNg9EN3DD3GsDXX7Aa8O4p92sryjkmzYYgmgTAc6CA4uGLEDzFfxOxugu21akOxpcXHiEgsYkC6nPsQvLLLmEg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "debug": "^4.3.4"
+ },
+ "bin": {
+ "read-binary-file-arch": "cli.js"
+ }
+ },
+ "node_modules/readdirp": {
+ "version": "3.6.0",
+ "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
+ "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
+ "license": "MIT",
+ "dependencies": {
+ "picomatch": "^2.2.1"
+ },
+ "engines": {
+ "node": ">=8.10.0"
+ }
+ },
+ "node_modules/regexp-tree": {
+ "version": "0.1.27",
+ "resolved": "https://registry.npmjs.org/regexp-tree/-/regexp-tree-0.1.27.tgz",
+ "integrity": "sha512-iETxpjK6YoRWJG5o6hXLwvjYAoW+FEZn9os0PD/b6AP6xQwsa/Y7lCVgIixBbUPMfhu+i2LtdeAqVTgGlQarfA==",
+ "dev": true,
+ "license": "MIT",
+ "bin": {
+ "regexp-tree": "bin/regexp-tree"
+ }
+ },
+ "node_modules/require-directory": {
+ "version": "2.1.1",
+ "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
+ "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/resedit": {
+ "version": "1.7.2",
+ "resolved": "https://registry.npmjs.org/resedit/-/resedit-1.7.2.tgz",
+ "integrity": "sha512-vHjcY2MlAITJhC0eRD/Vv8Vlgmu9Sd3LX9zZvtGzU5ZImdTN3+d6e/4mnTyV8vEbyf1sgNIrWxhWlrys52OkEA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "pe-library": "^0.4.1"
+ },
+ "engines": {
+ "node": ">=12",
+ "npm": ">=6"
+ },
+ "funding": {
+ "type": "github",
+ "url": "https://github.com/sponsors/jet2jet"
+ }
+ },
+ "node_modules/resolve-alpn": {
+ "version": "1.2.1",
+ "resolved": "https://registry.npmjs.org/resolve-alpn/-/resolve-alpn-1.2.1.tgz",
+ "integrity": "sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/responselike": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/responselike/-/responselike-2.0.1.tgz",
+ "integrity": "sha512-4gl03wn3hj1HP3yzgdI7d3lCkF95F21Pz4BPGvKHinyQzALR5CapwC8yIi0Rh58DEMQ/SguC03wFj2k0M/mHhw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "lowercase-keys": "^2.0.0"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/retry": {
+ "version": "0.12.0",
+ "resolved": "https://registry.npmjs.org/retry/-/retry-0.12.0.tgz",
+ "integrity": "sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 4"
+ }
+ },
+ "node_modules/rimraf": {
+ "version": "2.6.3",
+ "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.3.tgz",
+ "integrity": "sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA==",
+ "deprecated": "Rimraf versions prior to v4 are no longer supported",
+ "dev": true,
+ "license": "ISC",
+ "peer": true,
+ "dependencies": {
+ "glob": "^7.1.3"
+ },
+ "bin": {
+ "rimraf": "bin.js"
+ }
+ },
+ "node_modules/roarr": {
+ "version": "2.15.4",
+ "resolved": "https://registry.npmjs.org/roarr/-/roarr-2.15.4.tgz",
+ "integrity": "sha512-CHhPh+UNHD2GTXNYhPWLnU8ONHdI+5DI+4EYIAOaiD63rHeYlZvyh8P+in5999TTSFgUYuKUAjzRI4mdh/p+2A==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "optional": true,
+ "dependencies": {
+ "boolean": "^3.0.1",
+ "detect-node": "^2.0.4",
+ "globalthis": "^1.0.1",
+ "json-stringify-safe": "^5.0.1",
+ "semver-compare": "^1.0.0",
+ "sprintf-js": "^1.1.2"
+ },
+ "engines": {
+ "node": ">=8.0"
+ }
+ },
+ "node_modules/safe-regex": {
+ "version": "2.1.1",
+ "resolved": "https://registry.npmjs.org/safe-regex/-/safe-regex-2.1.1.tgz",
+ "integrity": "sha512-rx+x8AMzKb5Q5lQ95Zoi6ZbJqwCLkqi3XuJXp5P3rT8OEc6sZCJG5AE5dU3lsgRr/F4Bs31jSlVN+j5KrsGu9A==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "regexp-tree": "~0.1.1"
+ }
+ },
+ "node_modules/safer-buffer": {
+ "version": "2.1.2",
+ "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+ "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/sanitize-filename": {
+ "version": "1.6.4",
+ "resolved": "https://registry.npmjs.org/sanitize-filename/-/sanitize-filename-1.6.4.tgz",
+ "integrity": "sha512-9ZyI08PsvdQl2r/bBIGubpVdR3RR9sY6RDiWFPreA21C/EFlQhmgo20UZlNjZMMZNubusLhAQozkA0Od5J21Eg==",
+ "dev": true,
+ "license": "WTFPL OR ISC",
+ "dependencies": {
+ "truncate-utf8-bytes": "^1.0.0"
+ }
+ },
+ "node_modules/sax": {
+ "version": "1.6.0",
+ "resolved": "https://registry.npmjs.org/sax/-/sax-1.6.0.tgz",
+ "integrity": "sha512-6R3J5M4AcbtLUdZmRv2SygeVaM7IhrLXu9BmnOGmmACak8fiUtOsYNWUS4uK7upbmHIBbLBeFeI//477BKLBzA==",
+ "dev": true,
+ "license": "BlueOak-1.0.0",
+ "engines": {
+ "node": ">=11.0.0"
+ }
+ },
+ "node_modules/semver": {
+ "version": "6.3.1",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+ "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+ "dev": true,
+ "license": "ISC",
+ "bin": {
+ "semver": "bin/semver.js"
+ }
+ },
+ "node_modules/semver-compare": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/semver-compare/-/semver-compare-1.0.0.tgz",
+ "integrity": "sha512-YM3/ITh2MJ5MtzaM429anh+x2jiLVjqILF4m4oyQB18W7Ggea7BfqdH/wGMK7dDiMghv/6WG7znWMwUDzJiXow==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true
+ },
+ "node_modules/serialize-error": {
+ "version": "7.0.1",
+ "resolved": "https://registry.npmjs.org/serialize-error/-/serialize-error-7.0.1.tgz",
+ "integrity": "sha512-8I8TjW5KMOKsZQTvoxjuSIa7foAwPWGOts+6o7sgjz41/qMD9VQHEDxi6PBvK2l0MXUmqZyNpUK+T2tQaaElvw==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "type-fest": "^0.13.1"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/shebang-command": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+ "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "shebang-regex": "^3.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/shebang-regex": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+ "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/signal-exit": {
+ "version": "3.0.7",
+ "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
+ "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/simple-update-notifier": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/simple-update-notifier/-/simple-update-notifier-2.0.0.tgz",
+ "integrity": "sha512-a2B9Y0KlNXl9u/vsW6sTIu9vGEpfKu2wRV6l1H3XEas/0gUIzGzBoP/IouTcUQbm9JWZLH3COxyn03TYlFax6w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "semver": "^7.5.3"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/simple-update-notifier/node_modules/semver": {
+ "version": "7.7.4",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
+ "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+ "dev": true,
+ "license": "ISC",
+ "bin": {
+ "semver": "bin/semver.js"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/slice-ansi": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-3.0.0.tgz",
+ "integrity": "sha512-pSyv7bSTC7ig9Dcgbw9AuRNUb5k5V6oDudjZoMBSr13qpLBG7tB+zgCkARjq7xIUgdz5P1Qe8u+rSGdouOOIyQ==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "ansi-styles": "^4.0.0",
+ "astral-regex": "^2.0.0",
+ "is-fullwidth-code-point": "^3.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/smart-buffer": {
+ "version": "4.2.0",
+ "resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.2.0.tgz",
+ "integrity": "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "engines": {
+ "node": ">= 6.0.0",
+ "npm": ">= 3.0.0"
+ }
+ },
+ "node_modules/source-map": {
+ "version": "0.6.1",
+ "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+ "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/source-map-support": {
+ "version": "0.5.21",
+ "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz",
+ "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "buffer-from": "^1.0.0",
+ "source-map": "^0.6.0"
+ }
+ },
+ "node_modules/sprintf-js": {
+ "version": "1.1.3",
+ "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.1.3.tgz",
+ "integrity": "sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "optional": true
+ },
+ "node_modules/stat-mode": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/stat-mode/-/stat-mode-1.0.0.tgz",
+ "integrity": "sha512-jH9EhtKIjuXZ2cWxmXS8ZP80XyC3iasQxMDV8jzhNJpfDb7VbQLVW4Wvsxz9QZvzV+G4YoSfBUVKDOyxLzi/sg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 6"
+ }
+ },
+ "node_modules/string-width": {
+ "version": "4.2.3",
+ "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+ "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "emoji-regex": "^8.0.0",
+ "is-fullwidth-code-point": "^3.0.0",
+ "strip-ansi": "^6.0.1"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/strip-ansi": {
+ "version": "6.0.1",
+ "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+ "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "ansi-regex": "^5.0.1"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/sumchecker": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/sumchecker/-/sumchecker-3.0.1.tgz",
+ "integrity": "sha512-MvjXzkz/BOfyVDkG0oFOtBxHX2u3gKbMHIF/dXblZsgD3BWOFLmHovIpZY7BykJdAjcqRCBi1WYBNdEC9yI7vg==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "dependencies": {
+ "debug": "^4.1.0"
+ },
+ "engines": {
+ "node": ">= 8.0"
+ }
+ },
+ "node_modules/supports-color": {
+ "version": "7.2.0",
+ "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+ "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "has-flag": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/tar": {
+ "version": "7.5.13",
+ "resolved": "https://registry.npmjs.org/tar/-/tar-7.5.13.tgz",
+ "integrity": "sha512-tOG/7GyXpFevhXVh8jOPJrmtRpOTsYqUIkVdVooZYJS/z8WhfQUX8RJILmeuJNinGAMSu1veBr4asSHFt5/hng==",
+ "dev": true,
+ "license": "BlueOak-1.0.0",
+ "dependencies": {
+ "@isaacs/fs-minipass": "^4.0.0",
+ "chownr": "^3.0.0",
+ "minipass": "^7.1.2",
+ "minizlib": "^3.1.0",
+ "yallist": "^5.0.0"
+ },
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/tar/node_modules/yallist": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/yallist/-/yallist-5.0.0.tgz",
+ "integrity": "sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw==",
+ "dev": true,
+ "license": "BlueOak-1.0.0",
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/temp": {
+ "version": "0.9.4",
+ "resolved": "https://registry.npmjs.org/temp/-/temp-0.9.4.tgz",
+ "integrity": "sha512-yYrrsWnrXMcdsnu/7YMYAofM1ktpL5By7vZhf15CrXijWWrEYZks5AXBudalfSWJLlnen/QUJUB5aoB0kqZUGA==",
+ "dev": true,
+ "license": "MIT",
+ "peer": true,
+ "dependencies": {
+ "mkdirp": "^0.5.1",
+ "rimraf": "~2.6.2"
+ },
+ "engines": {
+ "node": ">=6.0.0"
+ }
+ },
+ "node_modules/temp-file": {
+ "version": "3.4.0",
+ "resolved": "https://registry.npmjs.org/temp-file/-/temp-file-3.4.0.tgz",
+ "integrity": "sha512-C5tjlC/HCtVUOi3KWVokd4vHVViOmGjtLwIh4MuzPo/nMYTV/p1urt3RnMz2IWXDdKEGJH3k5+KPxtqRsUYGtg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "async-exit-hook": "^2.0.1",
+ "fs-extra": "^10.0.0"
+ }
+ },
+ "node_modules/temp-file/node_modules/fs-extra": {
+ "version": "10.1.0",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",
+ "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "graceful-fs": "^4.2.0",
+ "jsonfile": "^6.0.1",
+ "universalify": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/temp-file/node_modules/jsonfile": {
+ "version": "6.2.1",
+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz",
+ "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "universalify": "^2.0.0"
+ },
+ "optionalDependencies": {
+ "graceful-fs": "^4.1.6"
+ }
+ },
+ "node_modules/temp-file/node_modules/universalify": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+ "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 10.0.0"
+ }
+ },
+ "node_modules/tiny-async-pool": {
+ "version": "1.3.0",
+ "resolved": "https://registry.npmjs.org/tiny-async-pool/-/tiny-async-pool-1.3.0.tgz",
+ "integrity": "sha512-01EAw5EDrcVrdgyCLgoSPvqznC0sVxDSVeiOz09FUpjh71G79VCqneOr+xvt7T1r76CF6ZZfPjHorN2+d+3mqA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "semver": "^5.5.0"
+ }
+ },
+ "node_modules/tiny-async-pool/node_modules/semver": {
+ "version": "5.7.2",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.2.tgz",
+ "integrity": "sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==",
+ "dev": true,
+ "license": "ISC",
+ "bin": {
+ "semver": "bin/semver"
+ }
+ },
+ "node_modules/tinyglobby": {
+ "version": "0.2.16",
+ "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.16.tgz",
+ "integrity": "sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "fdir": "^6.5.0",
+ "picomatch": "^4.0.4"
+ },
+ "engines": {
+ "node": ">=12.0.0"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/SuperchupuDev"
+ }
+ },
+ "node_modules/tinyglobby/node_modules/fdir": {
+ "version": "6.5.0",
+ "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+ "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=12.0.0"
+ },
+ "peerDependencies": {
+ "picomatch": "^3 || ^4"
+ },
+ "peerDependenciesMeta": {
+ "picomatch": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/tinyglobby/node_modules/picomatch": {
+ "version": "4.0.4",
+ "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
+ "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=12"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/jonschlinkert"
+ }
+ },
+ "node_modules/tmp": {
+ "version": "0.2.5",
+ "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.5.tgz",
+ "integrity": "sha512-voyz6MApa1rQGUxT3E+BK7/ROe8itEx7vD8/HEvt4xwXucvQ5G5oeEiHkmHZJuBO21RpOf+YYm9MOivj709jow==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=14.14"
+ }
+ },
+ "node_modules/tmp-promise": {
+ "version": "3.0.3",
+ "resolved": "https://registry.npmjs.org/tmp-promise/-/tmp-promise-3.0.3.tgz",
+ "integrity": "sha512-RwM7MoPojPxsOBYnyd2hy0bxtIlVrihNs9pj5SUvY8Zz1sQcQG2tG1hSr8PDxfgEB8RNKDhqbIlroIarSNDNsQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "tmp": "^0.2.0"
+ }
+ },
+ "node_modules/to-regex-range": {
+ "version": "5.0.1",
+ "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+ "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+ "license": "MIT",
+ "dependencies": {
+ "is-number": "^7.0.0"
+ },
+ "engines": {
+ "node": ">=8.0"
+ }
+ },
+ "node_modules/truncate-utf8-bytes": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/truncate-utf8-bytes/-/truncate-utf8-bytes-1.0.2.tgz",
+ "integrity": "sha512-95Pu1QXQvruGEhv62XCMO3Mm90GscOCClvrIUwCM0PYOXK3kaF3l3sIHxx71ThJfcbM2O5Au6SO3AWCSEfW4mQ==",
+ "dev": true,
+ "license": "WTFPL",
+ "dependencies": {
+ "utf8-byte-length": "^1.0.1"
+ }
+ },
+ "node_modules/type-check": {
+ "version": "0.4.0",
+ "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
+ "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "prelude-ls": "^1.2.1"
+ },
+ "engines": {
+ "node": ">= 0.8.0"
+ }
+ },
+ "node_modules/type-fest": {
+ "version": "0.13.1",
+ "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.13.1.tgz",
+ "integrity": "sha512-34R7HTnG0XIJcBSn5XhDd7nNFPRcXYRZrBB2O2jdKqYODldSzBAqzsWoZYYvduky73toYS/ESqxPvkDf/F0XMg==",
+ "dev": true,
+ "license": "(MIT OR CC0-1.0)",
+ "optional": true,
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/undici": {
+ "version": "7.29.0",
+ "resolved": "https://registry.npmjs.org/undici/-/undici-7.29.0.tgz",
+ "integrity": "sha512-IDxfleLmmbSskfWSUATiN1nfn2rDuvnMOqb5CWR92iIfojA0Ud+ulOAAEQ57LPr9rWmsreUyf5lwyao+7GNNVw==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=20.18.1"
+ }
+ },
+ "node_modules/undici-types": {
+ "version": "7.16.0",
+ "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.16.0.tgz",
+ "integrity": "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/universalify": {
+ "version": "0.1.2",
+ "resolved": "https://registry.npmjs.org/universalify/-/universalify-0.1.2.tgz",
+ "integrity": "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 4.0.0"
+ }
+ },
+ "node_modules/uri-js": {
+ "version": "4.4.1",
+ "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
+ "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "dependencies": {
+ "punycode": "^2.1.0"
+ }
+ },
+ "node_modules/utf8-byte-length": {
+ "version": "1.0.5",
+ "resolved": "https://registry.npmjs.org/utf8-byte-length/-/utf8-byte-length-1.0.5.tgz",
+ "integrity": "sha512-Xn0w3MtiQ6zoz2vFyUVruaCL53O/DwUvkEeOvj+uulMm0BkUGYWmBYVyElqZaSLhY6ZD0ulfU3aBra2aVT4xfA==",
+ "dev": true,
+ "license": "(WTFPL OR MIT)"
+ },
+ "node_modules/verror": {
+ "version": "1.10.1",
+ "resolved": "https://registry.npmjs.org/verror/-/verror-1.10.1.tgz",
+ "integrity": "sha512-veufcmxri4e3XSrT0xwfUR7kguIkaxBeosDg00yDWhk49wdwkSUrvvsm7nc75e1PUyvIeZj6nS8VQRYz2/S4Xg==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "assert-plus": "^1.0.0",
+ "core-util-is": "1.0.2",
+ "extsprintf": "^1.2.0"
+ },
+ "engines": {
+ "node": ">=0.6.0"
+ }
+ },
+ "node_modules/which": {
+ "version": "2.0.2",
+ "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+ "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "isexe": "^2.0.0"
+ },
+ "bin": {
+ "node-which": "bin/node-which"
+ },
+ "engines": {
+ "node": ">= 8"
+ }
+ },
+ "node_modules/word-wrap": {
+ "version": "1.2.5",
+ "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
+ "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/wrap-ansi": {
+ "version": "7.0.0",
+ "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+ "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "ansi-styles": "^4.0.0",
+ "string-width": "^4.1.0",
+ "strip-ansi": "^6.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+ }
+ },
+ "node_modules/wrappy": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+ "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/ws": {
+ "version": "8.21.0",
+ "resolved": "https://registry.npmjs.org/ws/-/ws-8.21.0.tgz",
+ "integrity": "sha512-Vsp28b7DRcimFQvrqu2Wek3z1iYxDCWqHYB8Qsnk/S4RfaCQzPGPyBNuVjJV3cd6UiKtUtp6sNM77gWvzcCH+g==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=10.0.0"
+ },
+ "peerDependencies": {
+ "bufferutil": "^4.0.1",
+ "utf-8-validate": ">=5.0.2"
+ },
+ "peerDependenciesMeta": {
+ "bufferutil": {
+ "optional": true
+ },
+ "utf-8-validate": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/xmlbuilder": {
+ "version": "15.1.1",
+ "resolved": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-15.1.1.tgz",
+ "integrity": "sha512-yMqGBqtXyeN1e3TGYvgNgDVZ3j84W4cwkOXQswghol6APgZWaff9lnbvN7MHYJOiXsvGPXtjTYJEiC9J2wv9Eg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8.0"
+ }
+ },
+ "node_modules/y18n": {
+ "version": "5.0.8",
+ "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
+ "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
+ "dev": true,
+ "license": "ISC",
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/yallist": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
+ "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/yargs": {
+ "version": "17.7.2",
+ "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
+ "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "cliui": "^8.0.1",
+ "escalade": "^3.1.1",
+ "get-caller-file": "^2.0.5",
+ "require-directory": "^2.1.1",
+ "string-width": "^4.2.3",
+ "y18n": "^5.0.5",
+ "yargs-parser": "^21.1.1"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/yargs-parser": {
+ "version": "21.1.1",
+ "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
+ "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
+ "dev": true,
+ "license": "ISC",
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/yauzl": {
+ "version": "2.10.0",
+ "resolved": "https://registry.npmjs.org/yauzl/-/yauzl-2.10.0.tgz",
+ "integrity": "sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "buffer-crc32": "~0.2.3",
+ "fd-slicer": "~1.1.0"
+ }
+ },
+ "node_modules/yocto-queue": {
+ "version": "0.1.0",
+ "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
+ "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ }
+ }
+}
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..36ca3d8
--- /dev/null
+++ b/package.json
@@ -0,0 +1,58 @@
+{
+ "name": "multi-hoster-uploader",
+ "version": "2.0.6",
+ "description": "Upload files to doodstream, voe, vidmoly, byse simultaneously",
+ "main": "main.js",
+ "scripts": {
+ "start": "electron .",
+ "test": "node --test tests/*.test.js tests/ui-smoke.js",
+ "test:backup-api": "npm --prefix services/backup-api test",
+ "lint": "eslint .",
+ "dist": "electron-builder --win",
+ "release:win": "electron-builder --publish never --win nsis portable"
+ },
+ "dependencies": {
+ "chokidar": "^3.6.0",
+ "undici": "^7.29.0",
+ "ws": "^8.21.0"
+ },
+ "devDependencies": {
+ "electron": "^41.3.0",
+ "electron-builder": "^26.8.1",
+ "eslint": "^10.1.0",
+ "eslint-plugin-security": "^4.0.0",
+ "rcedit": "^4.0.1"
+ },
+ "build": {
+ "appId": "com.multihoster.uploader",
+ "productName": "Multi-Hoster-Upload",
+ "directories": {
+ "buildResources": "assets",
+ "output": "release"
+ },
+ "files": [
+ "main.js",
+ "preload.js",
+ "preload-drop-target.js",
+ "lib/**/*",
+ "renderer/**/*",
+ "assets/app_icon.ico",
+ "assets/app_icon.png"
+ ],
+ "win": {
+ "target": [
+ "nsis",
+ "portable"
+ ],
+ "icon": "assets/app_icon.ico",
+ "signAndEditExecutable": false
+ },
+ "nsis": {
+ "oneClick": false,
+ "perMachine": false,
+ "allowToChangeInstallationDirectory": true,
+ "createDesktopShortcut": true
+ },
+ "afterPack": "scripts/afterPack.cjs"
+ }
+}
diff --git a/preload-drop-target.js b/preload-drop-target.js
new file mode 100644
index 0000000..3d11d02
--- /dev/null
+++ b/preload-drop-target.js
@@ -0,0 +1,5 @@
+const { contextBridge, ipcRenderer } = require('electron');
+
+contextBridge.exposeInMainWorld('dropTargetApi', {
+ sendFiles: (paths) => ipcRenderer.send('drop-target:files', paths)
+});
diff --git a/preload.js b/preload.js
new file mode 100644
index 0000000..39c2349
--- /dev/null
+++ b/preload.js
@@ -0,0 +1,173 @@
+const { contextBridge, ipcRenderer, webUtils } = require('electron');
+
+contextBridge.exposeInMainWorld('api', {
+ // Config
+ getConfig: () => ipcRenderer.invoke('get-config'),
+ saveConfig: (config) => ipcRenderer.invoke('save-config', config),
+ getHistory: () => ipcRenderer.invoke('get-history'),
+ clearHistory: () => ipcRenderer.invoke('clear-history'),
+ pruneHistory: (retention, opts) => ipcRenderer.invoke('prune-history', { retention, dryRun: !!(opts && opts.dryRun) }),
+ exportHistory: (format) => ipcRenderer.invoke('export-history', format),
+ saveTextFile: (defaultName, content, filters) => ipcRenderer.invoke('save-text-file', defaultName, content, filters),
+
+ // Hoster settings
+ getHosterSettings: () => ipcRenderer.invoke('get-hoster-settings'),
+ saveHosterSettings: (settings) => ipcRenderer.invoke('save-hoster-settings', settings),
+
+ // Global settings
+ getGlobalSettings: () => ipcRenderer.invoke('get-global-settings'),
+ saveGlobalSettings: (settings) => ipcRenderer.invoke('save-global-settings', settings),
+ savePendingQueue: (pendingQueue) => ipcRenderer.invoke('save-pending-queue', pendingQueue),
+ finishClosePreparation: (payload = true) => ipcRenderer.invoke('app:finish-close', payload),
+ onPrepareClose: (callback) => {
+ ipcRenderer.on('app:prepare-close', (_event, attempt) => {
+ ipcRenderer.send('app:close-preparation-started', attempt);
+ callback(attempt);
+ });
+ },
+ signalCloseHandshakeReady: () => ipcRenderer.send('app:close-handshake-ready'),
+
+ // Always on top
+ setAlwaysOnTop: (value) => ipcRenderer.invoke('set-always-on-top', value),
+ getAlwaysOnTop: () => ipcRenderer.invoke('get-always-on-top'),
+
+ // Shutdown after finish
+ setShutdownAfterFinish: (mode) => ipcRenderer.invoke('set-shutdown-after-finish', mode),
+ getShutdownAfterFinish: () => ipcRenderer.invoke('get-shutdown-after-finish'),
+ cancelShutdown: () => ipcRenderer.invoke('cancel-shutdown'),
+
+ // File selection
+ selectFiles: () => ipcRenderer.invoke('select-files'),
+ selectFolder: () => ipcRenderer.invoke('select-folder'),
+ selectFolderWithSizes: () => ipcRenderer.invoke('select-folder-with-sizes'),
+ resolveFolderFiles: (folderPath) => ipcRenderer.invoke('resolve-folder-files', folderPath),
+ getFileSizes: (paths) => ipcRenderer.invoke('get-file-sizes', paths),
+
+ // Upload control
+ startUpload: (payload) => ipcRenderer.invoke('start-upload', payload),
+ cancelUpload: () => ipcRenderer.invoke('cancel-upload'),
+ cancelSelectedJobs: (jobIds) => ipcRenderer.invoke('cancel-selected-jobs', jobIds),
+ addJobsToBatch: (payload) => ipcRenderer.invoke('add-jobs-to-batch', payload),
+ finishAfterActive: () => ipcRenderer.invoke('finish-after-active'),
+ runHealthCheck: (payload) => ipcRenderer.invoke('run-health-check', payload),
+ validateCredentials: (payload) => ipcRenderer.invoke('validate-credentials', payload),
+
+ // Log import
+ readOwnUploadLog: () => ipcRenderer.invoke('read-own-upload-log'),
+ importUploadLog: () => ipcRenderer.invoke('import-upload-log'),
+
+ // Clipboard
+ copyToClipboard: (text) => ipcRenderer.invoke('copy-to-clipboard', text),
+
+ // Updates
+ checkForUpdate: () => ipcRenderer.invoke('app:check-updates'),
+ installUpdate: () => ipcRenderer.invoke('app:install-update'),
+ abortUpdate: () => ipcRenderer.invoke('app:abort-update'),
+ getVersion: () => ipcRenderer.invoke('app:get-version'),
+ restartApp: () => ipcRenderer.invoke('app:restart'),
+ quitApp: () => ipcRenderer.invoke('app:quit'),
+ onUpdateAvailable: (callback) => {
+ ipcRenderer.on('app:update-available', (_event, data) => callback(data));
+ },
+ onUpdateProgress: (callback) => {
+ ipcRenderer.on('app:update-progress', (_event, data) => callback(data));
+ },
+
+ // Backup
+ exportBackup: () => ipcRenderer.invoke('export-backup'),
+ importBackup: (legacyPassword) => ipcRenderer.invoke('import-backup', legacyPassword),
+ createOnlineBackup: () => ipcRenderer.invoke('online-backup:create'),
+ restoreOnlineBackup: (key) => ipcRenderer.invoke('online-backup:restore', key),
+
+ // Folder Monitor
+ folderMonitorStart: (settings) => ipcRenderer.invoke('folder-monitor:start', settings),
+ folderMonitorStop: () => ipcRenderer.invoke('folder-monitor:stop'),
+ folderMonitorStatus: () => ipcRenderer.invoke('folder-monitor:status'),
+ folderMonitorSelectFolder: () => ipcRenderer.invoke('folder-monitor:select-folder'),
+ onFolderMonitorNewFiles: (callback) => {
+ ipcRenderer.on('folder-monitor:new-files', (_event, data) => callback(data));
+ },
+
+ // Account switched event
+ onAccountSwitched: (callback) => {
+ ipcRenderer.on('account-switched', (_event, data) => callback(data));
+ },
+
+ // Drop Target
+ showDropTarget: () => ipcRenderer.invoke('show-drop-target'),
+ hideDropTarget: () => ipcRenderer.invoke('hide-drop-target'),
+ onDropTargetFiles: (callback) => {
+ ipcRenderer.on('drop-target:files', (_event, paths) => callback(paths));
+ },
+
+ // Debug
+ debugTestUpload: () => ipcRenderer.invoke('debug-test-upload'),
+ debugLog: (msg) => ipcRenderer.invoke('debug-log', msg),
+
+ // Events (main -> renderer)
+ onUploadProgress: (callback) => {
+ ipcRenderer.on('upload-progress', (_event, data) => callback(data));
+ },
+ onUploadProgressBatch: (callback) => {
+ ipcRenderer.on('upload-progress-batch', (_event, batch) => callback(batch));
+ },
+ onUploadBatchDone: (callback) => {
+ ipcRenderer.on('upload-batch-done', (_event, data) => callback(data));
+ },
+ onUploadStats: (callback) => {
+ ipcRenderer.on('upload-stats', (_event, data) => callback(data));
+ },
+ onShutdownCountdown: (callback) => {
+ ipcRenderer.on('shutdown-countdown', (_event, data) => callback(data));
+ },
+ onUploadLogFallback: (callback) => {
+ ipcRenderer.on('upload-log-fallback', (_event, data) => callback(data));
+ },
+ onAccountRotationLog: (callback) => {
+ ipcRenderer.on('account-rotation-log', (_event, data) => callback(data));
+ },
+ openLogFolder: () => ipcRenderer.invoke('open-log-folder'),
+ getJobLog: (jobId) => ipcRenderer.invoke('get-job-log', jobId),
+ getSessionFailedAccounts: () => ipcRenderer.invoke('get-session-failed-accounts'),
+ resetSessionFailedAccount: (payload) => ipcRenderer.invoke('reset-session-failed-account', payload),
+ resetAllSessionFailedAccounts: () => ipcRenderer.invoke('reset-all-session-failed-accounts'),
+ getLogPaths: () => ipcRenderer.invoke('get-log-paths'),
+ testWebhook: (payload) => ipcRenderer.invoke('test-webhook', payload),
+ revealLogFile: (target) => ipcRenderer.invoke('reveal-log-file', target),
+ setLogVerbose: (enabled) => ipcRenderer.invoke('set-log-verbose', enabled),
+ createSupportBundle: () => ipcRenderer.invoke('create-support-bundle'),
+ getAppInfo: () => ipcRenderer.invoke('get-app-info'),
+ onLogPathAutoUpdated: (callback) => {
+ ipcRenderer.on('log-path-auto-updated', (_event, data) => callback(data));
+ },
+ // Remote Control
+ remoteGetSettings: () => ipcRenderer.invoke('remote:get-settings'),
+ remoteSaveSettings: (settings) => ipcRenderer.invoke('remote:save-settings', settings),
+ remoteGenerateToken: () => ipcRenderer.invoke('remote:generate-token'),
+ remoteStatus: () => ipcRenderer.invoke('remote:status'),
+ onRemoteClientCount: (callback) => {
+ ipcRenderer.on('remote:client-count', (_event, count) => callback(count));
+ },
+
+ // Remote Diagnostics (read-only)
+ diagnosticsGetSettings: () => ipcRenderer.invoke('diagnostics:get-settings'),
+ diagnosticsSaveSettings: (settings) => ipcRenderer.invoke('diagnostics:save-settings', settings),
+ diagnosticsRegenerate: () => ipcRenderer.invoke('diagnostics:regenerate'),
+ diagnosticsStatus: () => ipcRenderer.invoke('diagnostics:status'),
+
+ // File path from drag & drop (Electron 33+ compatible)
+ getPathForFile: (file) => webUtils.getPathForFile(file),
+ removeAllListeners: () => {
+ ipcRenderer.removeAllListeners('upload-progress');
+ ipcRenderer.removeAllListeners('upload-batch-done');
+ ipcRenderer.removeAllListeners('upload-stats');
+ ipcRenderer.removeAllListeners('app:update-available');
+ ipcRenderer.removeAllListeners('app:update-progress');
+ ipcRenderer.removeAllListeners('app:prepare-close');
+ ipcRenderer.removeAllListeners('shutdown-countdown');
+ ipcRenderer.removeAllListeners('folder-monitor:new-files');
+ ipcRenderer.removeAllListeners('drop-target:files');
+ ipcRenderer.removeAllListeners('account-switched');
+ ipcRenderer.removeAllListeners('remote:client-count');
+ }
+});
diff --git a/renderer/account-status.js b/renderer/account-status.js
new file mode 100644
index 0000000..c9d2add
--- /dev/null
+++ b/renderer/account-status.js
@@ -0,0 +1,36 @@
+(function (scope) {
+ const STATUS_PRESENTATIONS = {
+ ok: { statusClass: 'ok', label: 'Bereit', requiresOtp: false },
+ warn: { statusClass: 'warn', label: 'Warnung', requiresOtp: false },
+ checking: { statusClass: 'checking', label: 'Prüfe...', requiresOtp: false },
+ error: { statusClass: 'error', label: 'Fehler', requiresOtp: false },
+ otp_required: { statusClass: 'warn', label: 'OTP erforderlich', requiresOtp: true },
+ unchecked: { statusClass: 'unchecked', label: 'Nicht geprüft', requiresOtp: false },
+ disabled: { statusClass: 'disabled', label: 'Deaktiviert', requiresOtp: false }
+ };
+
+ function getAccountStatusPresentation(status) {
+ const presentation = STATUS_PRESENTATIONS[status] || STATUS_PRESENTATIONS.unchecked;
+ return { ...presentation };
+ }
+
+ function getAccountGroupStatus(summary) {
+ const total = Math.max(0, Number(summary && summary.total) || 0);
+ const disabled = Math.min(total, Math.max(0, Number(summary && summary.disabled) || 0));
+ const active = total - disabled;
+ const errors = Math.max(0, Number(summary && summary.error) || 0);
+ const ok = Math.max(0, Number(summary && summary.ok) || 0);
+ const warning = Math.max(0, Number(summary && summary.warn) || 0);
+ const checking = Math.max(0, Number(summary && summary.checking) || 0);
+ const unchecked = Math.max(0, Number(summary && summary.unchecked) || 0);
+ if (active === 0) return 'unchecked';
+ if (errors >= active) return 'error';
+ if (errors > 0 || warning > 0 || checking > 0 || unchecked > 0) return 'warn';
+ if (ok >= active) return 'ok';
+ return 'warn';
+ }
+
+ const accountStatus = { getAccountGroupStatus, getAccountStatusPresentation };
+ if (typeof module !== 'undefined' && module.exports) module.exports = accountStatus;
+ if (scope) scope.AccountStatus = accountStatus;
+})(typeof window !== 'undefined' ? window : globalThis);
diff --git a/renderer/account-submit.js b/renderer/account-submit.js
new file mode 100644
index 0000000..065202f
--- /dev/null
+++ b/renderer/account-submit.js
@@ -0,0 +1,73 @@
+(function (scope) {
+ function getAccountSubmitLabel() {
+ return 'Prüfen und speichern';
+ }
+
+ async function submitValidatedAccount({ validate, commit, afterCommit, isCurrent }) {
+ let validation;
+ try {
+ validation = await validate();
+ } catch (error) {
+ return { status: 'error', error };
+ }
+
+ try {
+ if (!isCurrent()) return { status: 'stale', validation };
+ } catch (error) {
+ return { status: 'error', error, validation };
+ }
+ if (validation && validation.status === 'otp_required') {
+ return { status: 'otp_required', validation };
+ }
+ if (!validation || (validation.status !== 'ok' && validation.status !== 'warn')) {
+ return { status: 'rejected', validation };
+ }
+
+ let value;
+ try {
+ value = await commit(validation);
+ } catch (error) {
+ return { status: 'error', error, validation };
+ }
+
+ let postCommitError;
+ if (typeof afterCommit === 'function') {
+ try {
+ await afterCommit(value, validation);
+ } catch (error) {
+ postCommitError = error;
+ }
+ }
+
+ const committedResult = { status: 'committed', committed: true, validation, value };
+ if (postCommitError) committedResult.postCommitError = postCommitError;
+ try {
+ if (!isCurrent()) return { ...committedResult, status: 'stale' };
+ } catch {
+ return { ...committedResult, status: 'stale' };
+ }
+ return committedResult;
+ }
+
+ function createAccountSubmitter() {
+ let pending = null;
+ return {
+ isBusy() {
+ return pending !== null;
+ },
+ submit(options) {
+ if (pending) return null;
+ const operation = submitValidatedAccount(options);
+ const tracked = operation.finally(() => {
+ if (pending === tracked) pending = null;
+ });
+ pending = tracked;
+ return tracked;
+ }
+ };
+ }
+
+ const accountSubmit = { createAccountSubmitter, getAccountSubmitLabel, submitValidatedAccount };
+ if (typeof module !== 'undefined' && module.exports) module.exports = accountSubmit;
+ if (scope) scope.AccountSubmit = accountSubmit;
+})(typeof window !== 'undefined' ? window : globalThis);
diff --git a/renderer/app.js b/renderer/app.js
new file mode 100644
index 0000000..5b63296
--- /dev/null
+++ b/renderer/app.js
@@ -0,0 +1,6751 @@
+const HOSTERS = ['doodstream.com', 'voe.sx', 'vidmoly.me', 'byse.sx', 'clouddrop.cc'];
+
+// Dropdown options for "Add Account" modal: value -> label
+const HOSTER_ADD_OPTIONS = [
+ { value: 'doodstream.com', label: 'Doodstream (Web Login)', hoster: 'doodstream.com', authType: 'login' },
+ { value: 'doodstream.com:api', label: 'Doodstream (API)', hoster: 'doodstream.com', authType: 'api' },
+ { value: 'voe.sx', label: 'Voe (Web Login)', hoster: 'voe.sx', authType: 'login' },
+ { value: 'voe.sx:api', label: 'Voe (API)', hoster: 'voe.sx', authType: 'api' },
+ { value: 'vidmoly.me', label: 'Vidmoly (Web Login)', hoster: 'vidmoly.me', authType: 'login' },
+ { value: 'byse.sx', label: 'Byse (API)', hoster: 'byse.sx', authType: 'api' },
+ { value: 'clouddrop.cc', label: 'Clouddrop (API)', hoster: 'clouddrop.cc', authType: 'api' }
+];
+
+// --- State ---
+let selectedFiles = []; // { path, name, size }
+let selectedUploadHosters = [];
+let config = { hosters: {}, hosterSettings: {}, globalSettings: {} };
+let hosterSettings = {};
+let uploading = false;
+let healthCheckRunning = false;
+
+let _rLongTasks = 0, _rLongTaskMax = 0, _rFrameLast = 0, _rFrameWorst = 0, _rFrameCount = 0, _rFrameJank = 0, _rPerfLastLog = 0, _rPerfWindowStart = 0;
+function _rElLabel(el) {
+ try {
+ if (!el || !el.tagName) return '?';
+ let s = el.tagName.toLowerCase();
+ if (el.id) s += '#' + el.id;
+ else if (el.className && typeof el.className === 'string') { const c = el.className.trim().split(/\s+/)[0]; if (c) s += '.' + c; }
+ const a = el.getAttribute && (el.getAttribute('data-action') || el.getAttribute('data-tab') || el.getAttribute('aria-label') || el.getAttribute('title'));
+ if (a) s += `[${String(a).slice(0, 24)}]`;
+ return s;
+ } catch { return '?'; }
+}
+try {
+ if (window.PerformanceObserver) {
+ new window.PerformanceObserver((list) => {
+ for (const e of list.getEntries()) {
+ _rLongTasks++;
+ if (e.duration > _rLongTaskMax) _rLongTaskMax = e.duration;
+ if (e.duration >= 100 && window.api && window.api.debugLog) window.api.debugLog(`renderer-longtask dur=${Math.round(e.duration)}ms`);
+ }
+ }).observe({ entryTypes: ['longtask'] });
+ }
+} catch {}
+try {
+ if (window.PerformanceObserver) {
+ new window.PerformanceObserver((list) => {
+ for (const e of list.getEntries()) {
+ const proc = Math.round((e.processingEnd || 0) - (e.processingStart || 0));
+ if (window.api && window.api.debugLog) window.api.debugLog(`renderer-interaction ${e.name} dur=${Math.round(e.duration)}ms proc=${proc}ms target=${_rElLabel(e.target)}`);
+ }
+ }).observe({ type: 'event', durationThreshold: 50, buffered: true });
+ }
+} catch {}
+function _rFrameTick(ts) {
+ if (_rFrameLast) { const d = ts - _rFrameLast; _rFrameCount++; if (d > _rFrameWorst) _rFrameWorst = d; if (d > 33) _rFrameJank++; }
+ _rFrameLast = ts;
+ requestAnimationFrame(_rFrameTick);
+}
+requestAnimationFrame(_rFrameTick);
+function _resetRendererPerf() {
+ _rPerfWindowStart = Date.now();
+ _rFrameCount = 0; _rFrameJank = 0; _rFrameWorst = 0; _rLongTasks = 0; _rLongTaskMax = 0;
+}
+function _maybeLogRendererPerf(activeJobs) {
+ const now = Date.now();
+ if (!_rPerfWindowStart) _rPerfWindowStart = now;
+ if (now - _rPerfLastLog < 5000) return;
+ const winSec = (now - _rPerfWindowStart) / 1000;
+ const fps = winSec > 0 ? Math.round(_rFrameCount / winSec) : 0;
+ if (window.api && window.api.debugLog) {
+ window.api.debugLog(`renderer-perf active=${activeJobs} fps=${fps} jankFrames=${_rFrameJank} worstFrame=${Math.round(_rFrameWorst)}ms longtasks=${_rLongTasks} maxTask=${Math.round(_rLongTaskMax)}ms`);
+ }
+ _rPerfLastLog = now;
+ _resetRendererPerf();
+}
+let accountStatuses = {}; // { accountId: { status: 'ok'|'warn'|'error'|'checking'|'unchecked', message: '' } }
+let editingAccountId = null; // null = adding, string = editing account by ID
+let autoHealthCheckEnabled = true;
+const queuePersistThrottle = (window.ThrottleTimer && window.ThrottleTimer.makeThrottleTimer)
+ ? window.ThrottleTimer.makeThrottleTimer()
+ : (function () {
+ let h = null;
+ let fn = null;
+ let burstStart = null;
+ function go() { h = null; burstStart = null; const g = fn; fn = null; if (g) g(); }
+ return {
+ request(f, d, maxWait) {
+ if (typeof f === 'function') fn = f;
+ const t = Date.now();
+ if (burstStart === null) burstStart = t;
+ let wait = typeof d === 'number' && d >= 0 ? d : 0;
+ if (typeof maxWait === 'number' && maxWait >= 0) {
+ const remaining = maxWait - (t - burstStart);
+ wait = Math.min(wait, remaining < 0 ? 0 : remaining);
+ }
+ clearTimeout(h);
+ h = setTimeout(go, wait);
+ },
+ flushSync() { clearTimeout(h); h = null; burstStart = null; const g = fn; fn = null; if (g) g(); },
+ cancel() { clearTimeout(h); h = null; burstStart = null; fn = null; },
+ isPending() { return h !== null; }
+ };
+ })();
+let configWriteQueue = Promise.resolve();
+const failedConfigWriteOperations = [];
+let configFlushPromise = null;
+let configWriteEpoch = 0;
+let configImportInProgress = false;
+let closePreparationState = 'open';
+let closeWriteAccessDepth = 0;
+
+function createSupersededConfigWriteError() {
+ const error = new Error('Einstellungen wurden durch einen Import ersetzt');
+ error.code = 'CONFIG_WRITE_SUPERSEDED';
+ return error;
+}
+
+function createClosedConfigWriteError() {
+ const error = new Error('Die Anwendung wird gerade beendet');
+ error.code = 'CONFIG_WRITE_CLOSED';
+ return error;
+}
+
+function beginConfigImport() {
+ if (configImportInProgress) throw new Error('Ein Einstellungsimport läuft bereits');
+ configImportInProgress = true;
+ configWriteEpoch++;
+}
+
+function endConfigImport() {
+ configImportInProgress = false;
+}
+
+function isConfigWriteImportGateError(error) {
+ return String(error && error.message ? error.message : error).includes('Einstellungen werden gerade importiert');
+}
+
+function retainFailedConfigWrite(operation, epoch, preserveAcrossImport) {
+ if (!failedConfigWriteOperations.some(entry => entry.operation === operation)) {
+ failedConfigWriteOperations.push({ operation, epoch, preserveAcrossImport });
+ }
+}
+
+async function retryFailedConfigWrites() {
+ while (failedConfigWriteOperations.length > 0) {
+ const entry = failedConfigWriteOperations[0];
+ if (entry.epoch !== configWriteEpoch && !entry.preserveAcrossImport) {
+ failedConfigWriteOperations.shift();
+ continue;
+ }
+ try {
+ await entry.operation();
+ failedConfigWriteOperations.shift();
+ } catch (error) {
+ if (isConfigWriteImportGateError(error)) {
+ failedConfigWriteOperations.shift();
+ continue;
+ }
+ throw error;
+ }
+ }
+}
+
+function enqueueConfigWriteOperation(operation) {
+ const promise = configWriteQueue.then(operation, operation);
+ const tail = promise.then(() => undefined, () => undefined);
+ configWriteQueue = tail;
+ return { promise, tail };
+}
+
+function runConfigWrite(operation, options = {}) {
+ const epoch = configWriteEpoch;
+ const preserveAcrossImport = options.preserveAcrossImport === true;
+ const allowedDuringClose = options.allowDuringClose === true || closeWriteAccessDepth > 0;
+ const blockedByImport = configImportInProgress && !preserveAcrossImport;
+ const blockedByClose = closePreparationState !== 'open' && !allowedDuringClose;
+ return enqueueConfigWriteOperation(async () => {
+ if (blockedByClose || (closePreparationState === 'sealed' && !allowedDuringClose)) throw createClosedConfigWriteError();
+ if (!preserveAcrossImport && (blockedByImport || configImportInProgress || epoch !== configWriteEpoch)) throw createSupersededConfigWriteError();
+ try {
+ await retryFailedConfigWrites();
+ } catch (error) {
+ retainFailedConfigWrite(operation, epoch, preserveAcrossImport);
+ throw error;
+ }
+ try {
+ return await operation();
+ } catch (error) {
+ if (!isConfigWriteImportGateError(error)) retainFailedConfigWrite(operation, epoch, preserveAcrossImport);
+ throw error;
+ }
+ }).promise;
+}
+
+async function withCloseWriteAccess(operation) {
+ closeWriteAccessDepth++;
+ try {
+ return await operation();
+ } finally {
+ closeWriteAccessDepth--;
+ }
+}
+
+function snapshotConfigWritePayload(payload) {
+ return structuredClone(payload);
+}
+
+function saveConfigTracked(configPatch) {
+ const payload = snapshotConfigWritePayload(configPatch);
+ return runConfigWrite(() => window.api.saveConfig(payload));
+}
+
+function saveHosterSettingsTracked(settings) {
+ const payload = snapshotConfigWritePayload(settings);
+ return runConfigWrite(() => window.api.saveHosterSettings(payload));
+}
+
+function saveGlobalSettingsTracked(settings) {
+ const payload = snapshotConfigWritePayload(settings);
+ return runConfigWrite(() => window.api.saveGlobalSettings(payload));
+}
+
+function savePendingQueueTracked(pendingQueue) {
+ const payload = snapshotConfigWritePayload(pendingQueue);
+ return runConfigWrite(() => window.api.savePendingQueue(payload), { preserveAcrossImport: true });
+}
+
+function setAlwaysOnTopTracked(value) {
+ const enabled = !!value;
+ return runConfigWrite(() => window.api.setAlwaysOnTop(enabled));
+}
+
+function saveDiagnosticsSettingsTracked(settings) {
+ const payload = snapshotConfigWritePayload(settings);
+ return runConfigWrite(() => window.api.diagnosticsSaveSettings(payload));
+}
+
+function saveRemoteSettingsTracked(settings) {
+ const payload = snapshotConfigWritePayload(settings);
+ return runConfigWrite(() => window.api.remoteSaveSettings(payload));
+}
+
+function flushConfigWrites() {
+ if (configFlushPromise) return configFlushPromise;
+ configFlushPromise = (async () => {
+ while (true) {
+ const { promise, tail } = enqueueConfigWriteOperation(retryFailedConfigWrites);
+ await promise;
+ if (configWriteQueue === tail && failedConfigWriteOperations.length === 0) return;
+ }
+ })();
+ configFlushPromise.then(
+ () => { configFlushPromise = null; },
+ () => { configFlushPromise = null; }
+ );
+ return configFlushPromise;
+}
+
+let _restoredSnapshotSavedAt = null;
+let settingsSaveTimer = null;
+const settingsSaveCoordinator = window.SerializedRunner.createSerializedRunner(performSaveSettings);
+let lastUploadStats = { state: 'idle', globalSpeedKbs: 0, totalBytes: 0, elapsed: 0, activeJobs: 0 };
+const AUTO_CHECK_PREF_KEY = 'autoHealthCheckBeforeUpload';
+const QUEUE_COL_WIDTHS_KEY = 'queueColumnWidthsPx';
+const STARTABLE_QUEUE_STATUSES = new Set(['preview', 'queued', 'error', 'aborted', 'skipped']);
+
+function isStartableQueueStatus(status) {
+ return STARTABLE_QUEUE_STATUSES.has(status);
+}
+
+function isStartableQueueJob(job) {
+ return !!job && isStartableQueueStatus(job.status);
+}
+
+// Queue state
+let queueJobs = []; // { id, file, fileName, hoster, status, bytesUploaded, bytesTotal, speedKbs, elapsed, remaining, error, result, attempt, maxAttempts, link }
+const _jobIndexById = new Map(); // id -> job (O(1) lookup)
+const _jobIndexByUploadId = new Map(); // uploadId -> job
+const selectedJobIds = new Set();
+let _sessionTotalBytes = 0; // Total bytes ever added to queue this session
+let _sessionUploadedBytes = 0; // Bytes fully uploaded this session (done jobs)
+const _sessionTrackedJobs = new Set(); // Job IDs already counted for totalBytes
+const _sessionDoneJobs = new Set(); // Job IDs already counted for uploadedBytes
+const _completedUploadKeys = new Set(); // 'filepath|hoster' keys for done uploads (survives removeFromQueueOnDone)
+const _suppressedPreviewKeys = new Set();
+const _deletedJobIds = new Set(); // IDs of jobs explicitly deleted by user (prevents re-creation from stale progress callbacks)
+// Coalesce removeFromQueueOnDone removals into one filter pass per microtask
+// to avoid O(N²) behaviour when a burst of jobs finish at once. Logic now
+// lives in lib/coalesced-set.js so it can be unit-tested with a manual
+// scheduler. Optional-chained so the renderer still works if the script
+// failed to load — falls back to immediate per-event filter (legacy slow
+// path), better than crashing.
+const _doneRemovalCoalescer = window.CoalescedSet
+ ? window.CoalescedSet.makeCoalescedSet({
+ apply: (drop) => { queueJobs = queueJobs.filter(j => !drop.has(j.id)); }
+ })
+ : null;
+const queueSortState = { key: 'filename', direction: 'asc' };
+let uploadSidebarFilter = 'all';
+let _queueFilterCache = { filter: '', source: null, result: [] };
+
+// History state
+let historyRowsData = [];
+let historySortState = { key: 'date', direction: 'desc' };
+let _historySortClicked = false;
+let historySidebarCounts = { total: 0, success: 0, error: 0 };
+let accountSidebarFilter = 'all';
+let historySidebarFilter = 'all';
+let _knownUpdateInfo = null;
+let _updateCheckBusy = false;
+let _updateInstallBusy = false;
+let _updateDialogReturnFocus = null;
+let _updateDialogInertState = [];
+
+// Session-specific files for the "Files" panel (resets each session)
+let sessionFilesData = [];
+let _recentSeqCounter = 0;
+let _recentDataVersion = 0;
+const recentSortState = { key: 'date', direction: 'desc' };
+const selectedRecentIds = new Set();
+// Maintained incrementally — avoids O(n) filter() scans every 250ms in the status bar.
+let _sessionDoneCount = 0;
+let _sessionErrorCount = 0;
+// O(1) dedup for maybeAddSessionFile (was O(n) sessionFilesData.some).
+// Huge with thousands of rows × thousands of incoming results.
+const _sessionFileKeys = new Set();
+
+window.addEventListener('error', (e) => {
+ try {
+ const msg = `RENDERER ERROR: ${e.message} at ${e.filename}:${e.lineno}:${e.colno}${e.error && e.error.stack ? '\n' + e.error.stack : ''}`;
+ if (window.api && window.api.debugLog) window.api.debugLog(msg);
+ } catch {}
+});
+window.addEventListener('unhandledrejection', (e) => {
+ try {
+ const reason = e.reason && e.reason.stack ? e.reason.stack : (e.reason && e.reason.message) || String(e.reason);
+ if (window.api && window.api.debugLog) window.api.debugLog(`RENDERER UNHANDLED REJECTION: ${reason}`);
+ } catch {}
+});
+
+// --- Init ---
+async function init() {
+ config = await window.api.getConfig();
+ hosterSettings = config.hosterSettings || {};
+ autoHealthCheckEnabled = loadAutoCheckPreference();
+ ensureAccountStatusEntries();
+ syncSelectedUploadHosters();
+ restoreQueueStateFromConfig();
+ await _autoDeduplicateFromLog();
+ _hydrateMissingJobSizes();
+ renderHosterSummary();
+ renderHosterModal();
+ renderSettings();
+ renderAccounts();
+ setupListeners();
+ setupDragDrop();
+ restoreQueueColumnWidths();
+ loadHistory();
+ _refreshSessionFailedSnapshot();
+ renderRecentUploadsPanel();
+ updateUploadView();
+ updateStatusBar();
+
+ // Version display
+ try {
+ const version = await window.api.getVersion();
+ const versionLabel = document.getElementById('versionLabel');
+ if (versionLabel) versionLabel.textContent = `v${version}`;
+ } catch {}
+
+ // Update listeners
+ window.api.onUpdateAvailable(showUpdateBanner);
+ window.api.onUpdateProgress(handleUpdateProgress);
+
+ window.api.onUploadProgress((data) => {
+ handleProgress(data);
+ });
+ if (window.api.onUploadProgressBatch) {
+ window.api.onUploadProgressBatch((batch) => {
+ if (!Array.isArray(batch)) return;
+ for (let i = 0; i < batch.length; i++) handleProgress(batch[i]);
+ });
+ }
+ window.api.onUploadBatchDone((data) => {
+ handleBatchDone(data);
+ });
+ window.api.onUploadStats((data) => {
+ handleStats(data);
+ });
+ window.api.onShutdownCountdown(handleShutdownCountdown);
+ window.api.onUploadLogFallback((data) => {
+ const path = data && data.fallbackPath ? data.fallbackPath : '(Fallback)';
+ showCopyToast(`Log-Pfad nicht beschreibbar — schreibe nach: ${path}`, 8000);
+ });
+ window.api.onLogPathAutoUpdated((data) => {
+ if (!data || !data.logFilePath) return;
+ // Keep the in-memory config and the visible Settings input in sync so
+ // the user sees the path that's actually being written to, and the
+ // next save from the UI doesn't revert it.
+ if (config && config.globalSettings) config.globalSettings.logFilePath = data.logFilePath;
+ const input = document.getElementById('logFilePathInput');
+ if (input) input.value = data.logFilePath;
+ showCopyToast(`Log-Pfad automatisch auf funktionierenden Ordner gesetzt`, 5000);
+ });
+ window.api.onAccountRotationLog((entry) => {
+ // Surface only the user-visible rotation events as toasts; full detail
+ // goes to account-rotation.log. Keep it quiet otherwise.
+ if (!entry || !entry.event) return;
+ const hosterLabel = entry.hoster ? getHosterLabel(entry.hoster) : '';
+ if (entry.event === 'rotate') {
+ showCopyToast(`${hosterLabel}: Account-Wechsel → Fallback`);
+ } else if (entry.event === 'rotation-end') {
+ showCopyToast(`${hosterLabel}: Keine weiteren Fallback-Accounts verfügbar`);
+ } else if (entry.event === 'final-error') {
+ showCopyToast(`${hosterLabel}: Alle Accounts ausgeschöpft`);
+ }
+ });
+
+ // Folder monitor: auto-queue new files
+ window.api.onFolderMonitorNewFiles((files) => {
+ window.api.debugLog('folder-monitor: received ' + files.length + ' file(s)');
+ const fm = config.globalSettings && config.globalSettings.folderMonitor;
+ const fmHosters = fm && Array.isArray(fm.hosters) && fm.hosters.length > 0 ? fm.hosters : [];
+
+ if (fmHosters.length > 0) {
+ // Pre-selected hosters: set them as active selection and add directly to queue
+ selectedUploadHosters = fmHosters.slice();
+ const existing = new Set();
+ for (const f of selectedFiles) existing.add(f.path);
+ for (const f of _pendingFiles) existing.add(f.path);
+ const newFiles = [];
+ for (const p of files) {
+ if (existing.has(p)) continue;
+ existing.add(p);
+ const name = p.split('\\').pop().split('/').pop();
+ newFiles.push({ path: p, name, size: null });
+ }
+ if (newFiles.length > 0) {
+ const newPaths = new Set(newFiles.map(f => f.path));
+ clearDedupKeysForPaths(newPaths);
+ selectedFiles.push(...newFiles);
+ buildQueuePreview();
+ updateUploadView();
+ if (fm.autoStart && !uploading && !healthCheckRunning) {
+ startUpload();
+ } else if (uploading) {
+ // Inject new preview jobs into the running batch
+ const newJobs = queueJobs.filter(j => j.status === 'preview' && newPaths.has(j.file));
+ if (newJobs.length > 0) {
+ newJobs.forEach(j => { j.status = 'queued'; });
+ renderQueueTable();
+ window.api.addJobsToBatch({
+ jobs: newJobs.map(j => ({ id: j.id, file: j.file, fileName: j.fileName, hoster: j.hoster }))
+ }).then(result => { _markSkippedJobs(result); }).catch(() => {});
+ persistQueueStateSoon(true);
+ }
+ }
+ }
+ } else {
+ // No pre-selected hosters: open modal
+ addPathsToQueue(files);
+ }
+ });
+
+ // Account switched notification
+ window.api.onAccountSwitched((data) => {
+ window.api.debugLog(`account-switched: ${data.hoster} ${data.fromAccountId} -> ${data.toAccountId}`);
+ });
+
+ // Drop target window: files dropped on the small floating window
+ window.api.onDropTargetFiles((paths) => {
+ addPathsToQueue(paths);
+ });
+
+ // Remote client count updates (registered once, not per renderSettings call)
+ window.api.onRemoteClientCount(() => {
+ const el = document.getElementById('remoteConnectionStatus');
+ if (el && el.style.color === 'rgb(16, 185, 129)') {
+ window.api.remoteStatus().then(status => {
+ if (status.running) {
+ el.textContent = `Aktiv auf Port ${status.port} — ${status.clientCount} Client(s) verbunden`;
+ }
+ }).catch(() => {});
+ }
+ });
+
+ window.api.debugLog('init complete, all listeners registered');
+
+ // Restore always-on-top state
+ try {
+ const onTop = await window.api.getAlwaysOnTop();
+ alwaysOnTopState = !!onTop;
+ } catch {}
+
+ scheduleStartupAccountCheck();
+}
+
+// --- Tab switching ---
+let _historyDirty = false;
+let _historyEverLoaded = false;
+function _isHistoryTabActive() {
+ const tab = document.querySelector('.tab.active');
+ return !!(tab && tab.dataset.view === 'history');
+}
+// Cache the tab/view collections once and use event delegation on the parent
+// so tab switches don't trigger three querySelectorAll walks per click.
+(() => {
+ const tabs = Array.from(document.querySelectorAll('.tab'));
+ const views = Array.from(document.querySelectorAll('.view'));
+ const tabsByView = {};
+ const viewsById = {};
+ for (const t of tabs) tabsByView[t.dataset.view] = t;
+ for (const v of views) viewsById[v.id] = v;
+ let activeTab = tabs.find(t => t.classList.contains('active')) || tabs[0];
+
+ const handle = (target) => {
+ const tab = target.closest('.tab');
+ if (!tab || tab === activeTab) return;
+ if (activeTab) {
+ activeTab.classList.remove('active');
+ activeTab.setAttribute('aria-selected', 'false');
+ activeTab.tabIndex = -1;
+ const prevView = viewsById[`${activeTab.dataset.view}-view`];
+ if (prevView) prevView.classList.remove('active');
+ }
+ tab.classList.add('active');
+ tab.setAttribute('aria-selected', 'true');
+ tab.tabIndex = 0;
+ const nextView = viewsById[`${tab.dataset.view}-view`];
+ if (nextView) nextView.classList.add('active');
+ activeTab = tab;
+ if (tab.dataset.view === 'history' && (_historyDirty || !_historyEverLoaded)) {
+ loadHistory();
+ }
+ };
+
+ const tabBar = tabs[0] && tabs[0].parentElement;
+ if (tabBar) {
+ tabBar.addEventListener('click', (e) => handle(e.target));
+ tabBar.addEventListener('keydown', (e) => {
+ if (!['ArrowLeft', 'ArrowRight', 'Home', 'End'].includes(e.key)) return;
+ e.preventDefault();
+ const current = Math.max(0, tabs.indexOf(activeTab));
+ const next = e.key === 'Home'
+ ? 0
+ : e.key === 'End'
+ ? tabs.length - 1
+ : (current + (e.key === 'ArrowRight' ? 1 : -1) + tabs.length) % tabs.length;
+ tabs[next].focus();
+ handle(tabs[next]);
+ });
+ } else {
+ // Fallback: bind per-tab if somehow no common parent
+ tabs.forEach(t => t.addEventListener('click', () => handle(t)));
+ }
+})();
+
+// --- Top menu bar (Datei / Einstellungen / Hilfe) ---
+function initMenuBar() {
+ const menuBar = document.getElementById('menuBar');
+ if (!menuBar) return;
+ let openMenu = null;
+
+ const dropdowns = {};
+ menuBar.querySelectorAll('[data-menu-dropdown]').forEach(d => { dropdowns[d.dataset.menuDropdown] = d; });
+ const triggers = {};
+ menuBar.querySelectorAll('[data-menu-trigger]').forEach(t => { triggers[t.dataset.menuTrigger] = t; });
+
+ function closeMenus() {
+ openMenu = null;
+ for (const k in dropdowns) dropdowns[k].style.display = 'none';
+ for (const k in triggers) triggers[k].classList.remove('open');
+ menuBar.querySelectorAll('.menu-submenu-dropdown').forEach(s => { s.style.display = 'none'; });
+ }
+
+ function openMenuNamed(name) {
+ if (openMenu === name) return;
+ closeMenus();
+ openMenu = name;
+ if (dropdowns[name]) dropdowns[name].style.display = '';
+ if (triggers[name]) triggers[name].classList.add('open');
+ if (name === 'einstellungen') _syncMenuSettings();
+ }
+
+ menuBar.querySelectorAll('[data-menu-trigger]').forEach(trigger => {
+ const name = trigger.dataset.menuTrigger;
+ trigger.addEventListener('click', (e) => {
+ e.stopPropagation();
+ if (openMenu === name) closeMenus(); else openMenuNamed(name);
+ });
+ trigger.addEventListener('mouseenter', () => { if (openMenu && openMenu !== name) openMenuNamed(name); });
+ });
+
+ menuBar.querySelectorAll('.menu-submenu').forEach(sm => {
+ const sub = sm.querySelector('.menu-submenu-dropdown');
+ sm.addEventListener('mouseenter', () => { if (sub) sub.style.display = ''; });
+ sm.addEventListener('mouseleave', () => { if (sub) sub.style.display = 'none'; });
+ });
+
+ menuBar.querySelectorAll('[data-menu-action]').forEach(item => {
+ item.addEventListener('click', (e) => {
+ e.stopPropagation();
+ const action = item.dataset.menuAction;
+ closeMenus();
+ _handleMenuAction(action);
+ });
+ });
+
+ document.addEventListener('mousedown', (e) => { if (openMenu && !e.target.closest('.menu-bar')) closeMenus(); });
+ document.addEventListener('keydown', (e) => { if (e.key === 'Escape' && openMenu) closeMenus(); });
+
+ _initMenuSettingsControls();
+}
+
+async function _handleMenuAction(action) {
+ switch (action) {
+ case 'add-files': document.getElementById('addFilesBtn')?.click(); break;
+ case 'add-folder': document.getElementById('addFolderBtn')?.click(); break;
+ case 'backup-export': doBackupExport(); break;
+ case 'backup-import': doBackupImport(); break;
+ case 'online-backup-create': doOnlineBackupCreate(); break;
+ case 'online-backup-restore': openOnlineBackupRestore(); break;
+ case 'restart': if (confirm('Anwendung neu starten?')) window.api.restartApp(); break;
+ case 'quit': window.api.quitApp(); break;
+ case 'open-settings': document.querySelector('.tab[data-view="settings"]')?.click(); break;
+ case 'open-log-folder': window.api.openLogFolder(); break;
+ case 'support-bundle': {
+ showCopyToast('Diagnose-Paket wird erstellt…');
+ try {
+ const res = await window.api.createSupportBundle();
+ if (res && res.ok) showCopyToast(`Diagnose-Paket gespeichert (${(res.bytes / 1024).toFixed(1)} KB)`);
+ else if (res && res.canceled) showCopyToast('Abgebrochen');
+ else showCopyToast(`Fehler: ${(res && res.error) || 'unbekannt'}`);
+ } catch (err) { showCopyToast(`Fehler: ${err.message || err}`); }
+ break;
+ }
+ case 'check-updates': {
+ await requestUpdateCheck();
+ break;
+ }
+ }
+}
+
+function _setHeaderUpdateLabel(text) {
+ const button = document.getElementById('headerUpdateBtn');
+ if (!button) return;
+ const label = button.querySelector('[data-update-label], .header-update-label');
+ if (label) label.textContent = text;
+ else button.textContent = text;
+}
+
+function _syncHeaderUpdateState() {
+ const button = document.getElementById('headerUpdateBtn');
+ const available = !!(_knownUpdateInfo && _knownUpdateInfo.available);
+ const version = available ? String(_knownUpdateInfo.remoteVersion || '').replace(/^v/i, '') : '';
+ const hint = _updateCheckBusy
+ ? 'Suche nach Aktualisierungen…'
+ : available
+ ? `Update v${version || 'unbekannt'} verfügbar. Klicken zum Installieren.`
+ : 'Nach Aktualisierungen suchen';
+ if (button) {
+ button.classList.toggle('update-available', available);
+ button.classList.toggle('is-checking', _updateCheckBusy);
+ button.disabled = _updateCheckBusy;
+ button.setAttribute('aria-busy', _updateCheckBusy ? 'true' : 'false');
+ button.setAttribute('aria-label', hint);
+ button.title = hint;
+ button.dataset.tooltip = hint;
+ _setHeaderUpdateLabel(_updateCheckBusy ? 'Prüfen…' : (available ? 'Update verfügbar' : 'Update'));
+ }
+ const manualButton = document.getElementById('manualUpdateCheckBtn');
+ if (manualButton) {
+ manualButton.disabled = _updateCheckBusy;
+ manualButton.setAttribute('aria-busy', _updateCheckBusy ? 'true' : 'false');
+ manualButton.textContent = _updateCheckBusy ? 'Prüfe…' : (available ? 'Update verfügbar' : 'Nach Updates suchen');
+ }
+}
+
+async function requestUpdateCheck() {
+ if (_knownUpdateInfo && _knownUpdateInfo.available) {
+ showUpdateBanner(_knownUpdateInfo);
+ return _knownUpdateInfo;
+ }
+ if (_updateCheckBusy) return null;
+ _updateCheckBusy = true;
+ _syncHeaderUpdateState();
+ showCopyToast('Suche nach Updates…');
+ try {
+ const result = await window.api.checkForUpdate();
+ if (result && result.available) {
+ showUpdateBanner(result);
+ showCopyToast('Update gefunden!');
+ } else if (result && result.error) {
+ showCopyToast('Updateprüfung fehlgeschlagen');
+ } else {
+ showCopyToast('Kein Update verfügbar');
+ }
+ return result;
+ } catch {
+ showCopyToast('Updateprüfung fehlgeschlagen');
+ return null;
+ } finally {
+ _updateCheckBusy = false;
+ _syncHeaderUpdateState();
+ }
+}
+
+function _syncMenuSettings() {
+ const gs = config.globalSettings || {};
+ const pInput = document.getElementById('menuParallelInput');
+ if (pInput) pInput.value = String(gs.parallelUploadCount ?? 0);
+ const speedKbs = gs.globalMaxSpeedKbs || 0;
+ const enabled = speedKbs > 0;
+ const sCheck = document.getElementById('menuSpeedLimitCheck');
+ const sInput = document.getElementById('menuSpeedInput');
+ const sSpinner = document.getElementById('menuSpeedSpinner');
+ if (sCheck) sCheck.checked = enabled;
+ if (sInput) sInput.value = enabled ? String(+(speedKbs / 1024).toFixed(2)) : '0';
+ if (sSpinner) sSpinner.classList.toggle('disabled', !enabled);
+}
+
+function _menuSaveParallel(v) {
+ const n = Math.max(0, Math.min(100, parseInt(v, 10) || 0));
+ const gs = { ...(config.globalSettings || {}), parallelUploadCount: n };
+ config.globalSettings = gs;
+ saveGlobalSettingsTracked(gs).catch(() => {});
+ const mirror = document.getElementById('parallelUploadCountInput');
+ if (mirror) mirror.value = String(n);
+ return n;
+}
+
+function _menuSaveSpeedMbs(mbs, enabled) {
+ const kbs = enabled ? Math.max(0, Math.round((parseFloat(mbs) || 0) * 1024)) : 0;
+ const gs = { ...(config.globalSettings || {}), globalMaxSpeedKbs: kbs };
+ config.globalSettings = gs;
+ saveGlobalSettingsTracked(gs).catch(() => {});
+ const mirror = document.getElementById('globalMaxSpeedMbsInput');
+ if (mirror) mirror.value = kbs > 0 ? String(+(kbs / 1024).toFixed(2)) : '0';
+}
+
+function _initMenuSettingsControls() {
+ const grid = document.getElementById('menuSettingsGrid');
+ if (grid) grid.addEventListener('click', (e) => e.stopPropagation());
+
+ const pInput = document.getElementById('menuParallelInput');
+ if (pInput) {
+ const save = () => { pInput.value = String(_menuSaveParallel(pInput.value)); };
+ pInput.addEventListener('change', save);
+ pInput.addEventListener('blur', save);
+ }
+
+ const sInput = document.getElementById('menuSpeedInput');
+ const sCheck = document.getElementById('menuSpeedLimitCheck');
+ const sSpinner = document.getElementById('menuSpeedSpinner');
+ if (sCheck) sCheck.addEventListener('change', () => {
+ if (sSpinner) sSpinner.classList.toggle('disabled', !sCheck.checked);
+ _menuSaveSpeedMbs(sInput ? sInput.value : 0, sCheck.checked);
+ });
+ if (sInput) {
+ const save = () => _menuSaveSpeedMbs(sInput.value, sCheck ? sCheck.checked : true);
+ sInput.addEventListener('change', save);
+ sInput.addEventListener('blur', save);
+ }
+
+ document.querySelectorAll('#menuSettingsGrid [data-spin]').forEach(btn => {
+ btn.addEventListener('click', (e) => {
+ e.stopPropagation();
+ const kind = btn.dataset.spin;
+ if (kind === 'parallel-up' || kind === 'parallel-down') {
+ const cur = parseInt(pInput.value, 10) || 0;
+ pInput.value = String(_menuSaveParallel(cur + (kind === 'parallel-up' ? 1 : -1)));
+ } else if (kind === 'speed-up' || kind === 'speed-down') {
+ const cur = parseFloat(sInput.value) || 0;
+ const next = Math.max(0, cur + (kind === 'speed-up' ? 1 : -1));
+ sInput.value = String(next);
+ _menuSaveSpeedMbs(next, sCheck ? sCheck.checked : true);
+ }
+ });
+ });
+}
+
+// --- Hoster selection ---
+function accountHasCreds(name, account) {
+ if (!account) return false;
+ if (account.authType === 'api') return !!account.apiKey;
+ if (account.authType === 'login') return !!(account.username && account.password);
+ // Fallback
+ if (name === 'vidmoly.me') return !!(account.username && account.password);
+ if (name === 'voe.sx' || name === 'doodstream.com') return !!(account.username && account.password) || !!account.apiKey;
+ return !!account.apiKey;
+}
+
+// Returns hosters that have at least one enabled account with credentials
+function getAvailableHosters() {
+ const result = [];
+ for (const name of HOSTERS) {
+ const accounts = config.hosters[name];
+ if (!Array.isArray(accounts)) continue;
+ const hasEnabledAccount = accounts.some(a => a.enabled !== false && accountHasCreds(name, a));
+ if (hasEnabledAccount) result.push({ name });
+ }
+ return result;
+}
+
+function syncSelectedUploadHosters() {
+ const available = new Set(getAvailableHosters().map(item => item.name));
+ selectedUploadHosters = selectedUploadHosters.filter(name => available.has(name));
+ if (selectedUploadHosters.length === 0) {
+ selectedUploadHosters = HOSTERS.filter(name => {
+ const accounts = config.hosters[name];
+ return Array.isArray(accounts) && accounts.some(a => a.enabled !== false && accountHasCreds(name, a));
+ });
+ }
+}
+
+function getSelectedHosters() {
+ return selectedUploadHosters.slice();
+}
+
+function getHosterLabel(name) {
+ const labels = {
+ 'doodstream.com': 'Doodstream',
+ 'voe.sx': 'VOE',
+ 'vidmoly.me': 'Vidmoly',
+ 'byse.sx': 'Byse',
+ 'clouddrop.cc': 'Clouddrop'
+ };
+ return labels[name] || name;
+}
+
+function getAccountAuthLabel(account) {
+ if (!account) return '';
+ if (account.authType === 'api') return 'API';
+ if (account.authType === 'login') return 'Web Login';
+ return '';
+}
+
+function getAccountDisplayName(name, account) {
+ const authLabel = getAccountAuthLabel(account);
+ return authLabel
+ ? `${getHosterLabel(name)} (${authLabel})`
+ : getHosterLabel(name);
+}
+
+function maskCredential(value, keep = 4) {
+ const text = String(value || '').trim();
+ if (!text) return '';
+ if (text.length <= keep) return text;
+ return `${text.slice(0, keep)}…${text.slice(-2)}`;
+}
+
+function ensureAccountStatusEntries() {
+ const nextStatuses = {};
+ for (const { account } of getAllAccountsFlat()) {
+ if (account.id) {
+ nextStatuses[account.id] = accountStatuses[account.id] || { status: 'unchecked', message: '' };
+ }
+ }
+ accountStatuses = nextStatuses;
+}
+
+// Returns flat array of all accounts: [{ name, account, index }]
+function getAllAccountsFlat() {
+ const result = [];
+ for (const name of HOSTERS) {
+ const accounts = config.hosters[name];
+ if (!Array.isArray(accounts)) continue;
+ accounts.forEach((account, index) => result.push({ name, account, index }));
+ }
+ return result;
+}
+
+// Returns flat array of accounts with credentials
+function getAccountsWithCredsFlat() {
+ return getAllAccountsFlat().filter(({ name, account }) => accountHasCreds(name, account));
+}
+
+// Find account by ID across all hosters
+function findAccountById(accountId) {
+ for (const name of HOSTERS) {
+ const accounts = config.hosters[name];
+ if (!Array.isArray(accounts)) continue;
+ const account = accounts.find(a => a.id === accountId);
+ if (account) return { name, account };
+ }
+ return null;
+}
+
+function scheduleStartupAccountCheck() {
+ const accounts = getAccountsWithCredsFlat();
+ if (!accounts.length) return;
+ setTimeout(() => {
+ runHealthCheck('startup').catch(() => {});
+ }, 500);
+}
+
+function renderHosterSummary() {
+ const summary = document.getElementById('hosterSummary');
+ if (!summary) return;
+ const hosters = getSelectedHosters();
+ if (hosters.length === 0) {
+ summary.textContent = 'Keine Upload-Ziele ausgewählt';
+ } else if (hosters.length === 1) {
+ summary.textContent = `Aktives Ziel: ${getHosterLabel(hosters[0])}`;
+ } else {
+ summary.textContent = `${hosters.length} Ziele aktiv: ${hosters.map((name) => getHosterLabel(name)).join(', ')}`;
+ }
+}
+
+function renderHosterModal() {
+ const list = document.getElementById('hosterModalList');
+ const hint = document.getElementById('hosterModalHint');
+ if (!list || !hint) return;
+
+ const available = getAvailableHosters();
+ if (available.length === 0) {
+ list.innerHTML = '';
+ hint.textContent = 'Keine Hoster mit Zugangsdaten vorhanden. Bitte zuerst in den Accounts einen Login oder API-Key hinterlegen.';
+ return;
+ }
+
+ list.innerHTML = available.map(item => {
+ const checked = selectedUploadHosters.includes(item.name);
+ // Get first enabled account's status for subtitle
+ const accounts = config.hosters[item.name] || [];
+ const enabledAccounts = accounts.filter(a => a.enabled !== false && accountHasCreds(item.name, a));
+ const accountCount = enabledAccounts.length;
+ let subtitle = `${accountCount} Account${accountCount !== 1 ? 's' : ''}`;
+ // Check if any account has ok status
+ const hasOk = enabledAccounts.some(a => accountStatuses[a.id] && accountStatuses[a.id].status === 'ok');
+ const hasError = enabledAccounts.some(a => accountStatuses[a.id] && accountStatuses[a.id].status === 'error');
+ if (hasOk) subtitle += ' • Bereit';
+ else if (hasError) subtitle += ' • Fehler';
+ return `
+
+ `;
+ }).join('');
+
+ hint.textContent = 'Die Auswahl wird für neue Queue-Einträge verwendet.';
+
+ list.querySelectorAll('input[data-hoster-modal]').forEach(input => {
+ input.addEventListener('change', () => {
+ input.closest('.hoster-option')?.classList.toggle('selected', input.checked);
+ });
+ });
+}
+
+function openHosterModal() {
+ syncSelectedUploadHosters();
+ renderHosterModal();
+ document.getElementById('hosterModal').style.display = 'flex';
+}
+
+function closeHosterModal() {
+ const modal = document.getElementById('hosterModal');
+ if (modal) modal.style.display = 'none';
+}
+
+function applyHosterSelection() {
+ selectedUploadHosters = Array.from(document.querySelectorAll('input[data-hoster-modal]:checked'))
+ .map(input => input.dataset.hosterModal);
+ // Move pending files to selectedFiles on confirm
+ const pendingPaths = new Set(_pendingFiles.map(f => f.path));
+ if (_pendingFiles.length > 0) {
+ selectedFiles.push(..._pendingFiles);
+ _pendingFiles = [];
+ }
+ clearDedupKeysForPaths(pendingPaths);
+ renderHosterSummary();
+
+ // During an active upload, build preview jobs for the new files and inject
+ // them into the running batch immediately (otherwise they'd be lost on
+ // handleBatchDone via syncSelectedFilesFromQueue)
+ if (uploading && pendingPaths.size > 0) {
+ buildQueuePreview(); // creates 'preview' jobs for new files
+ const newJobs = queueJobs.filter(j => j.status === 'preview' && pendingPaths.has(j.file));
+ if (newJobs.length > 0) {
+ newJobs.forEach(j => { j.status = 'queued'; });
+ renderQueueTable();
+ window.api.addJobsToBatch({
+ jobs: newJobs.map(j => ({ id: j.id, file: j.file, fileName: j.fileName, hoster: j.hoster }))
+ }).then(result => { _markSkippedJobs(result); }).catch(() => {});
+ persistQueueStateSoon(true);
+ }
+ }
+
+ updateUploadView();
+ persistQueueStateSoon(true); // immediate persist after adding files
+ document.getElementById('hosterModal').style.display = 'none';
+}
+
+function cancelHosterModal() {
+ _pendingFiles = [];
+ closeHosterModal();
+}
+
+function normalizeRestoredJobStatus(status) {
+ if (status === 'done' || status === 'error' || status === 'skipped' || status === 'preview' || status === 'aborted') return status;
+ return 'queued';
+}
+
+function restoreQueueStateFromConfig() {
+ if (config?.globalSettings?.resumeQueueOnLaunch === false) return;
+ const pending = config?.globalSettings?.pendingQueue;
+ if (!pending || typeof pending !== 'object') return;
+
+ _restoredSnapshotSavedAt = (typeof pending.savedAt === 'number' && isFinite(pending.savedAt))
+ ? pending.savedAt
+ : null;
+
+ if (Array.isArray(pending.completedKeys)) {
+ for (const k of pending.completedKeys) {
+ if (typeof k === 'string' && k) _completedUploadKeys.add(k);
+ }
+ }
+
+ if (Array.isArray(pending.suppressedKeys)) {
+ for (const k of pending.suppressedKeys) {
+ if (typeof k === 'string' && k) _suppressedPreviewKeys.add(k);
+ }
+ }
+
+ selectedUploadHosters = Array.isArray(pending.selectedUploadHosters)
+ ? pending.selectedUploadHosters.filter(Boolean)
+ : selectedUploadHosters;
+
+ selectedFiles = Array.isArray(pending.selectedFiles)
+ ? pending.selectedFiles
+ .filter(file => file && file.path)
+ .map(file => ({ path: file.path, name: file.name || file.path.split(/[\\/]/).pop(), size: file.size || 0 }))
+ : [];
+
+ const rawJobs = Array.isArray(pending.queueJobs)
+ ? pending.queueJobs
+ .filter(job => job && job.fileName && job.hoster)
+ .map(job => ({
+ id: job.id || `restored-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+ uploadId: null,
+ file: job.file || '',
+ fileName: job.fileName,
+ hoster: job.hoster,
+ status: normalizeRestoredJobStatus(job.status),
+ bytesUploaded: job.status === 'done' ? (job.bytesTotal || 0) : 0,
+ bytesTotal: job.bytesTotal || 0,
+ speedKbs: 0,
+ elapsed: 0,
+ remaining: 0,
+ error: job.error || null,
+ result: job.result || null,
+ attempt: 0,
+ maxAttempts: job.maxAttempts || 0,
+ link: '',
+ progress: job.status === 'done' ? 1 : 0
+ }))
+ : [];
+
+ // Deduplicate: keep the job with the best status for each file+hoster pair
+ const seen = new Map();
+ const statusPriority = { done: 0, uploading: 1, queued: 2, preview: 3, error: 4, aborted: 5, skipped: 6 };
+ for (const job of rawJobs) {
+ const key = `${job.file}|${job.hoster}`;
+ const existing = seen.get(key);
+ if (!existing || (statusPriority[job.status] ?? 9) < (statusPriority[existing.status] ?? 9)) {
+ seen.set(key, job);
+ }
+ }
+ queueJobs = Array.from(seen.values());
+ rebuildJobIndex();
+}
+
+function buildPersistedQueueState() {
+ const persistableJobs = queueJobs.filter(job => !['done', 'skipped'].includes(job.status));
+ const selectedFileMap = new Map(selectedFiles.map(file => [file.path, file]));
+
+ for (const job of persistableJobs) {
+ if (job.file && !selectedFileMap.has(job.file)) {
+ selectedFileMap.set(job.file, {
+ path: job.file,
+ name: job.fileName,
+ size: job.bytesTotal || 0
+ });
+ }
+ }
+
+ if (selectedFileMap.size === 0 && queueJobs.every(job => ['done', 'skipped'].includes(job.status))) {
+ return null;
+ }
+
+ // After a restart no upload manager is running, so any in-flight state
+ // (queued / getting-server / uploading / retrying / aborted) is
+ // meaningless. Collapse them all to 'preview' so the queue shows a
+ // consistent "Bereit" for everything that didn't actually terminate.
+ // Only true terminal states (done / error / skipped) survive as-is.
+ const TERMINAL = new Set(['done', 'error', 'skipped']);
+ const completedKeys = [];
+ for (const k of _completedUploadKeys) {
+ const sep = k.lastIndexOf('|');
+ if (sep > 0 && selectedFileMap.has(k.slice(0, sep))) completedKeys.push(k);
+ }
+ const suppressedKeys = [];
+ for (const k of _suppressedPreviewKeys) {
+ const sep = k.lastIndexOf('|');
+ if (sep > 0 && selectedFileMap.has(k.slice(0, sep))) suppressedKeys.push(k);
+ }
+ return {
+ savedAt: Date.now(),
+ selectedUploadHosters: getSelectedHosters(),
+ selectedFiles: Array.from(selectedFileMap.values()),
+ completedKeys,
+ suppressedKeys,
+ queueJobs: queueJobs.map(job => {
+ const isTerminal = TERMINAL.has(job.status);
+ return {
+ id: job.id,
+ file: job.file,
+ fileName: job.fileName,
+ hoster: job.hoster,
+ status: isTerminal ? job.status : 'preview',
+ bytesTotal: job.bytesTotal || 0,
+ error: isTerminal ? (job.error || null) : null,
+ result: isTerminal ? (job.result || null) : null,
+ maxAttempts: job.maxAttempts || 0
+ };
+ })
+ };
+}
+
+async function persistQueueStateNow() {
+ const pendingQueue = buildPersistedQueueState();
+ const globalSettings = {
+ ...(config.globalSettings || {}),
+ pendingQueue
+ };
+ config.globalSettings = globalSettings;
+ await savePendingQueueTracked(pendingQueue);
+ return pendingQueue;
+}
+
+function persistQueueStateSoon(immediate) {
+ if (closePreparationState !== 'open') return;
+ if (immediate) {
+ queuePersistThrottle.cancel();
+ persistQueueStateNow().catch(() => {});
+ return;
+ }
+ const maxWait = uploading ? 20000 : undefined;
+ queuePersistThrottle.request(() => {
+ persistQueueStateNow().catch(() => {});
+ }, 500, maxWait);
+}
+
+function clearPersistedQueueStateSoon() {
+ if (closePreparationState !== 'open') return;
+ queuePersistThrottle.request(() => {
+ config.globalSettings = { ...(config.globalSettings || {}), pendingQueue: null };
+ savePendingQueueTracked(null).catch(() => {});
+ }, 0);
+}
+
+// --- File selection ---
+function setupDragDrop() {
+ const dropZone = document.getElementById('dropZone');
+ // Allow drop on the entire upload view
+ const uploadView = document.getElementById('upload-view');
+ let _dragCounter = 0;
+ dropZone.addEventListener('dragover', (e) => { e.preventDefault(); e.stopPropagation(); });
+ dropZone.addEventListener('dragenter', (e) => { e.preventDefault(); _dragCounter++; dropZone.classList.add('drag-over'); });
+ dropZone.addEventListener('dragleave', (e) => { e.preventDefault(); _dragCounter--; if (_dragCounter <= 0) { _dragCounter = 0; dropZone.classList.remove('drag-over'); } });
+ dropZone.addEventListener('drop', (e) => {
+ e.preventDefault(); e.stopPropagation(); _dragCounter = 0; dropZone.classList.remove('drag-over');
+ addDroppedFiles(e.dataTransfer.files).catch(console.error);
+ });
+ dropZone.addEventListener('click', () => pickFiles());
+
+ // Also handle drops on queue container
+ uploadView.addEventListener('dragover', (e) => { e.preventDefault(); });
+ uploadView.addEventListener('drop', (e) => {
+ e.preventDefault();
+ if (e.target.closest('.drop-zone')) return; // handled above
+ addDroppedFiles(e.dataTransfer.files).catch(console.error);
+ });
+}
+
+let _pendingFiles = []; // Files waiting for hoster modal confirmation
+
+let _addingDropped = false;
+
+async function addDroppedFiles(fileList) {
+ if (_addingDropped) return;
+ _addingDropped = true;
+ try {
+ const files = Array.from(fileList);
+ const existingPaths = new Set([
+ ...selectedFiles.map(f => f.path),
+ ..._pendingFiles.map(f => f.path)
+ ]);
+ const newFiles = [];
+
+ for (const file of files) {
+ let filePath = '';
+ try { filePath = window.api.getPathForFile(file); } catch { filePath = file.path || ''; }
+ if (!filePath) continue;
+
+ // Detect folders: directories report size 0 and empty type in Electron drag-and-drop
+ if (file.type === '' && file.size === 0) {
+ try {
+ const folderFiles = await window.api.resolveFolderFiles(filePath);
+ if (folderFiles && folderFiles.length > 0) {
+ for (const fp of folderFiles) {
+ const p = typeof fp === 'string' ? fp : (fp && fp.path);
+ if (!p || existingPaths.has(p)) continue;
+ const name = typeof fp === 'string' ? p.split('\\').pop().split('/').pop() : (fp.name || p.split('\\').pop().split('/').pop());
+ const size = typeof fp === 'string' ? null : (fp.size || 0);
+ newFiles.push({ path: p, name, size });
+ existingPaths.add(p);
+ }
+ continue;
+ }
+ } catch {}
+ }
+
+ // Regular file
+ const fileName = file.name || '';
+ if (!existingPaths.has(filePath)) {
+ newFiles.push({ path: filePath, name: fileName, size: file.size });
+ existingPaths.add(filePath);
+ }
+ }
+
+ if (newFiles.length > 0) {
+ _pendingFiles.push(...newFiles);
+ openHosterModal();
+ }
+ } finally {
+ _addingDropped = false;
+ }
+}
+
+async function pickFiles() {
+ const paths = await window.api.selectFiles();
+ if (!paths) return;
+ addPathsToQueue(paths);
+}
+
+async function pickFolder() {
+ const richFiles = window.api.selectFolderWithSizes ? await window.api.selectFolderWithSizes() : null;
+ if (richFiles && Array.isArray(richFiles)) { addPathsToQueue(richFiles); return; }
+ const paths = await window.api.selectFolder();
+ if (!paths) return;
+ addPathsToQueue(paths);
+}
+
+function addPathsToQueue(paths) {
+ const existing = new Set();
+ for (const f of selectedFiles) existing.add(f.path);
+ for (const f of _pendingFiles) existing.add(f.path);
+
+ const newFiles = [];
+ const pendingSizeFetch = [];
+ for (const entry of paths) {
+ const p = typeof entry === 'string' ? entry : (entry && entry.path);
+ if (!p || existing.has(p)) continue;
+ existing.add(p);
+ const name = typeof entry === 'string' ? p.split('\\').pop().split('/').pop() : (entry.name || p.split('\\').pop().split('/').pop());
+ const size = typeof entry === 'string' ? null : (entry.size || 0);
+ newFiles.push({ path: p, name, size });
+ if (size === null || size === undefined || size === 0) pendingSizeFetch.push(p);
+ }
+ if (newFiles.length > 0) {
+ _pendingFiles.push(...newFiles);
+ openHosterModal();
+ if (pendingSizeFetch.length > 0 && window.api.getFileSizes) {
+ window.api.getFileSizes(pendingSizeFetch).then((sizeMap) => {
+ if (!sizeMap || typeof sizeMap !== 'object') return;
+ let changed = false;
+ for (const f of _pendingFiles) {
+ if (sizeMap[f.path] && (!f.size || f.size === 0)) { f.size = sizeMap[f.path]; changed = true; }
+ }
+ for (const f of selectedFiles) {
+ if (sizeMap[f.path] && (!f.size || f.size === 0)) { f.size = sizeMap[f.path]; changed = true; }
+ }
+ for (const j of queueJobs) {
+ if (sizeMap[j.file] && (!j.bytesTotal || j.bytesTotal === 0)) { j.bytesTotal = sizeMap[j.file]; changed = true; }
+ }
+ if (changed) {
+ _queueStatsCache = null;
+ if (typeof renderQueueTable === 'function') renderQueueTable();
+ if (typeof updateStatusBar === 'function') updateStatusBar();
+ }
+ }).catch(() => {});
+ }
+ }
+}
+
+function updateUploadView() {
+ const dropZone = document.getElementById('dropZone');
+ const queueShell = document.getElementById('queueShell');
+ const queueActions = document.getElementById('queueActions');
+
+ if (selectedFiles.length === 0 && queueJobs.length === 0) {
+ dropZone.style.display = 'flex';
+ queueShell.style.display = 'none';
+ queueActions.style.display = 'none';
+ } else {
+ dropZone.style.display = 'none';
+ queueShell.style.display = 'flex';
+ queueActions.style.display = 'flex';
+ if (!uploading && selectedFiles.length > 0) {
+ buildQueuePreview();
+ }
+ }
+ updateQueueActionButtons();
+}
+
+function updateStartButton() {
+ const btn = document.getElementById('startUploadBtn');
+ const hosters = getSelectedHosters();
+ const hasQueuedJobs = queueJobs.some(isStartableQueueJob);
+ const canBuildQueueFromSelection = selectedFiles.length > 0 && hosters.length > 0;
+ btn.disabled = uploading || !(hasQueuedJobs || canBuildQueueFromSelection);
+}
+
+const _UPLOAD_SELECTION_STATUSES = new Set(['done', 'error', 'aborted', 'skipped']);
+const _ABORT_SELECTION_STATUSES = new Set(['preview', 'queued', 'getting-server', 'uploading', 'retrying']);
+
+function updateQueueActionButtons() {
+ updateStartButton();
+ _normalizeQueueSelectionToVisible();
+
+ const hasSelection = selectedJobIds.size > 0;
+ // Single pass over the (usually small) selection set instead of three O(n)
+ // scans over the entire queue. For 1000 jobs × 3 scans this drops the
+ // selection-change cost from ~3000 checks to |selection|.
+ let hasUploadSelection = false, hasAbortSelection = false, hasStartableSelection = false;
+ for (const id of selectedJobIds) {
+ const job = _jobIndexById.get(id);
+ if (!job) continue;
+ const s = job.status;
+ if (!hasUploadSelection && _UPLOAD_SELECTION_STATUSES.has(s)) hasUploadSelection = true;
+ if (!hasAbortSelection && _ABORT_SELECTION_STATUSES.has(s)) hasAbortSelection = true;
+ if (!hasStartableSelection && isStartableQueueStatus(s)) hasStartableSelection = true;
+ if (hasUploadSelection && hasAbortSelection && hasStartableSelection) break;
+ }
+ const hasMovableSelection = hasSelection && !uploading;
+
+ const startSelectedBtn = document.getElementById('startSelectedBtn');
+ const reuploadBtn = document.getElementById('reuploadSelectedBtn');
+ const abortSelectedBtn = document.getElementById('abortSelectedBtn');
+ const finishStopBtn = document.getElementById('finishStopBtn');
+ const abortAllBtn = document.getElementById('abortAllBtn');
+ const moveTopBtn = document.getElementById('moveTopBtn');
+ const moveUpBtn = document.getElementById('moveUpBtn');
+ const moveDownBtn = document.getElementById('moveDownBtn');
+ const moveBottomBtn = document.getElementById('moveBottomBtn');
+
+ if (startSelectedBtn) startSelectedBtn.disabled = uploading || !hasStartableSelection;
+ if (reuploadBtn) reuploadBtn.disabled = !hasUploadSelection;
+ if (abortSelectedBtn) abortSelectedBtn.disabled = !hasAbortSelection;
+ if (finishStopBtn) finishStopBtn.disabled = !uploading;
+ if (abortAllBtn) abortAllBtn.disabled = !uploading;
+ if (moveTopBtn) moveTopBtn.disabled = !hasMovableSelection;
+ if (moveUpBtn) moveUpBtn.disabled = !hasMovableSelection;
+ if (moveDownBtn) moveDownBtn.disabled = !hasMovableSelection;
+ if (moveBottomBtn) moveBottomBtn.disabled = !hasMovableSelection;
+}
+
+function clearDedupKeysForPaths(pathSet) {
+ if (!pathSet || pathSet.size === 0) return;
+ for (const set of [_completedUploadKeys, _suppressedPreviewKeys]) {
+ for (const key of [...set]) {
+ const sep = key.lastIndexOf('|');
+ if (sep > 0 && pathSet.has(key.slice(0, sep))) set.delete(key);
+ }
+ }
+}
+
+function suppressPreviewKeysStillSelected(keys) {
+ if (!keys || keys.length === 0) return;
+ const stillSelected = new Set(selectedFiles.map(f => f.path));
+ for (const key of keys) {
+ const sep = key.lastIndexOf('|');
+ if (sep > 0 && stillSelected.has(key.slice(0, sep))) _suppressedPreviewKeys.add(key);
+ }
+}
+
+// Build preview jobs from selected files x selected hosters (before upload starts)
+function buildQueuePreview() {
+ const hosters = getSelectedHosters();
+ if (hosters.length === 0) {
+ queueJobs = queueJobs.filter(j => j.status !== 'preview');
+ rebuildJobIndex();
+ renderQueueTable();
+ persistQueueStateSoon();
+ return;
+ }
+ // Remove old preview jobs
+ queueJobs = queueJobs.filter(j => j.status !== 'preview');
+
+ // Build a Set for fast existence checks
+ const existingKeys = new Set();
+ for (const j of queueJobs) {
+ existingKeys.add(`${j.file}|${j.hoster}`);
+ }
+
+ for (const file of selectedFiles) {
+ for (const hoster of hosters) {
+ const key = `${file.path}|${hoster}`;
+ if (!existingKeys.has(key) && !_completedUploadKeys.has(key) && !_suppressedPreviewKeys.has(key)) {
+ const job = {
+ id: `preview-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+ file: file.path, fileName: file.name, hoster,
+ status: 'preview', bytesUploaded: 0, bytesTotal: file.size || 0,
+ speedKbs: 0, elapsed: 0, remaining: 0,
+ error: null, result: null, attempt: 0, maxAttempts: 0, link: ''
+ };
+ queueJobs.push(job);
+ existingKeys.add(key);
+ }
+ }
+ }
+ rebuildJobIndex();
+ renderQueueTable();
+ persistQueueStateSoon();
+}
+
+// --- Job Index Management ---
+function rebuildJobIndex() {
+ _jobIndexById.clear();
+ _jobIndexByUploadId.clear();
+ for (const job of queueJobs) {
+ _jobIndexById.set(job.id, job);
+ if (job.uploadId) _jobIndexByUploadId.set(job.uploadId, job);
+ }
+}
+
+function indexJob(job) {
+ _jobIndexById.set(job.id, job);
+ if (job.uploadId) _jobIndexByUploadId.set(job.uploadId, job);
+}
+
+function removeJobFromIndex(job, keepCompletedKey) {
+ _jobIndexById.delete(job.id);
+ if (job.uploadId) _jobIndexByUploadId.delete(job.uploadId);
+ // Track deletion so handleProgress() won't re-create this job from stale callbacks
+ _deletedJobIds.add(job.id);
+ if (job.uploadId) _deletedJobIds.add(job.uploadId);
+ // Allow re-uploading same file+hoster after deletion
+ if (!keepCompletedKey && job.file && job.hoster) _completedUploadKeys.delete(`${job.file}|${job.hoster}`);
+}
+
+// --- Queue Table Rendering (debounced with virtual scrolling) ---
+let _renderQueued = false;
+let _sortedJobsCache = [];
+const VIRTUAL_ROW_HEIGHT = 28;
+const VIRTUAL_OVERSCAN = 10;
+let _lastVisibleRange = { start: -1, end: -1 };
+let _queueListenersBound = false;
+
+// Throttled UI update scheduling – max one render per 200ms during uploads
+let _uiUpdateTimer = null;
+const UI_UPDATE_INTERVAL = 200; // ms
+
+function scheduleQueueRender() {
+ if (_renderQueued) return;
+ _renderQueued = true;
+ requestAnimationFrame(() => { _renderQueued = false; renderQueueTable(); });
+}
+
+let _recentRenderQueued = false;
+function scheduleRecentRender() {
+ if (_recentRenderQueued) return;
+ _recentRenderQueued = true;
+ requestAnimationFrame(() => { _recentRenderQueued = false; renderRecentUploadsPanel(true); });
+}
+
+// Toggle the .selected class on existing rows without rebuilding the table.
+// Used on click/selection changes — O(rendered rows) instead of O(total rows × sort).
+// Uses getElementsByClassName for the live HTMLCollection (DOM-cached after the
+// first call, auto-tracks insertions/removals on tbody) instead of running a
+// fresh querySelectorAll on every click. At 200 visible rows that's the
+// difference between paying for a tree walk per click vs reading a memoized
+// list that the engine already maintains.
+function applyQueueSelectionClasses() {
+ const tbody = document.getElementById('queueBody');
+ if (!tbody) return;
+ const rows = tbody.getElementsByClassName('queue-row');
+ for (let i = 0; i < rows.length; i++) {
+ const tr = rows[i];
+ tr.classList.toggle('selected', selectedJobIds.has(tr.dataset.jobId));
+ }
+}
+
+function applyRecentSelectionClasses() {
+ const tbody = document.getElementById('recentFilesBody');
+ if (!tbody) return;
+ const rows = tbody.getElementsByClassName('recent-file-row');
+ for (let i = 0; i < rows.length; i++) {
+ const tr = rows[i];
+ const order = parseInt(tr.dataset.order, 10);
+ tr.classList.toggle('selected', selectedRecentIds.has(order));
+ }
+}
+
+function scheduleThrottledUIUpdate() {
+ if (_uiUpdateTimer) return;
+ _uiUpdateTimer = setTimeout(() => {
+ _uiUpdateTimer = null;
+ scheduleQueueRender();
+ updateQueueActionButtons();
+ updateStatusBar();
+ updateStatsPanel();
+ }, UI_UPDATE_INTERVAL);
+}
+
+// Coalesces status-change updates (done/error/retrying/queued/…) into one
+// frame. Without this, a batch of 500 jobs flipping queued→getting-server
+// →uploading synchronously fires 1500+ updateStatusBar/Buttons/Stats calls
+// and janks the renderer. rAF caps it to ~60 Hz.
+let _statusChangeUpdateQueued = false;
+function scheduleStatusChangeUpdate() {
+ if (_statusChangeUpdateQueued) return;
+ _statusChangeUpdateQueued = true;
+ requestAnimationFrame(() => {
+ _statusChangeUpdateQueued = false;
+ renderQueueTable();
+ updateQueueActionButtons();
+ updateStatusBar();
+ updateStatsPanel();
+ });
+}
+
+function _hydrateMissingJobSizes(jobsLike) {
+ if (!window.api || !window.api.getFileSizes) return;
+ const paths = [];
+ const seen = new Set();
+ const source = Array.isArray(jobsLike) ? jobsLike : queueJobs;
+ for (const j of source) {
+ if (!j || !j.file) continue;
+ if (j.bytesTotal && j.bytesTotal > 0) continue;
+ if (seen.has(j.file)) continue;
+ seen.add(j.file);
+ paths.push(j.file);
+ }
+ if (paths.length === 0) return;
+ window.api.getFileSizes(paths).then((sizeMap) => {
+ if (!sizeMap || typeof sizeMap !== 'object') return;
+ let changed = false;
+ for (const j of queueJobs) {
+ if (sizeMap[j.file] && (!j.bytesTotal || j.bytesTotal === 0)) {
+ j.bytesTotal = sizeMap[j.file];
+ changed = true;
+ }
+ }
+ for (const f of selectedFiles) {
+ if (sizeMap[f.path] && (!f.size || f.size === 0)) f.size = sizeMap[f.path];
+ }
+ if (changed) {
+ _queueStatsCache = null;
+ if (typeof renderQueueTable === 'function') renderQueueTable();
+ if (typeof updateStatusBar === 'function') updateStatusBar();
+ }
+ }).catch(() => {});
+}
+
+function _formatUploadedSize(job) {
+ const bt = job.bytesTotal || 0;
+ const bu = job.bytesUploaded || 0;
+ const s = job.status;
+ if (s === 'preview') return bt > 0 ? formatSize(bt) : '...';
+ if (s === 'queued' || s === 'getting-server' || s === 'retrying') {
+ return bt > 0 ? `${formatSize(bu)} / ${formatSize(bt)}` : '...';
+ }
+ return `${formatSize(bu)} / ${formatSize(bt)}`;
+}
+
+function buildRowHtml(job) {
+ const statusClass = `status-${job.status}`;
+ const rowClass = `queue-row ${statusClass}${selectedJobIds.has(job.id) ? ' selected' : ''}`;
+ const uploadedSize = _formatUploadedSize(job);
+ const statusText = getStatusText(job);
+ const elapsed = formatTime(job.elapsed);
+ const remaining = formatTime(job.remaining);
+ const speed = job.speedKbs > 0 ? `${formatSpeed(job.speedKbs)}` : '';
+ const pct = Math.min(100, Math.round((job.progress || 0) * 100));
+ const link = job.result ? (job.result.download_url || job.result.embed_url || '') : '';
+
+ return `
+ | ${escapeHtml(job.fileName)} |
+ ${uploadedSize} |
+ ${escapeHtml(job.hoster)} |
+ ${escapeHtml(statusText)} |
+ ${elapsed} |
+ ${remaining} |
+ ${speed} |
+
+
+
+ ${job.status === 'preview' ? '' : pct + '%'}
+ |
+
`;
+}
+
+// In-place update of a single row's cells (avoids full innerHTML rebuild)
+function _updateRowInPlace(tr, job) {
+ const statusClass = `status-${job.status}`;
+ const uploadedSize = _formatUploadedSize(job);
+ const statusText = getStatusText(job);
+ const elapsed = formatTime(job.elapsed);
+ const remaining = formatTime(job.remaining);
+ const speed = job.speedKbs > 0 ? `${formatSpeed(job.speedKbs)}` : '';
+ const pct = Math.min(100, Math.round((job.progress || 0) * 100));
+ const link = job.result ? (job.result.download_url || job.result.embed_url || '') : '';
+
+ // Write DOM only when the target value actually changes — a no-op progress
+ // tick (same pct, same speed) then performs zero DOM work. Massive saver
+ // when most of the visible jobs are idle/queued/done and only a few are
+ // actively uploading.
+ const newClass = `queue-row ${statusClass}${selectedJobIds.has(job.id) ? ' selected' : ''}`;
+ if (tr.className !== newClass) tr.className = newClass;
+ if (tr.dataset.link !== link) tr.dataset.link = link;
+
+ const cells = tr.children;
+ if (cells.length < 8) return false; // structure mismatch, needs full rebuild
+
+ if (cells[1].textContent !== uploadedSize) cells[1].textContent = uploadedSize;
+ // cells[0] (filename) and cells[2] (hoster) don't change during upload
+ const badge = cells[3].querySelector('.status-badge');
+ if (badge) {
+ const badgeClass = `status-badge ${statusClass}`;
+ if (badge.className !== badgeClass) badge.className = badgeClass;
+ if (badge.textContent !== statusText) badge.textContent = statusText;
+ }
+ if (cells[4].textContent !== elapsed) cells[4].textContent = elapsed;
+ if (cells[5].textContent !== remaining) cells[5].textContent = remaining;
+ if (cells[6].textContent !== speed) cells[6].textContent = speed;
+
+ const fill = cells[7].querySelector('.progress-bar-fill');
+ if (fill) {
+ const pctStr = pct + '%';
+ if (fill.style.width !== pctStr) fill.style.width = pctStr;
+ const fillClass = `progress-bar-fill ${statusClass}`;
+ if (fill.className !== fillClass) fill.className = fillClass;
+ }
+ const pctSpan = cells[7].querySelector('.progress-pct');
+ if (pctSpan) {
+ const pctText = job.status === 'preview' ? '' : pct + '%';
+ if (pctSpan.textContent !== pctText) pctSpan.textContent = pctText;
+ }
+
+ return true;
+}
+
+function _matchesUploadSidebarFilter(job, filter = uploadSidebarFilter) {
+ if (filter === 'active') return job.status === 'uploading' || job.status === 'getting-server' || job.status === 'retrying';
+ if (filter === 'waiting') return job.status === 'preview' || job.status === 'queued';
+ if (filter === 'done') return job.status === 'done';
+ if (filter === 'error') return job.status === 'error';
+ return true;
+}
+
+function _getVisibleQueueJobs() {
+ if (uploadSidebarFilter === 'all') return queueJobs;
+ const filtered = queueJobs.filter(job => _matchesUploadSidebarFilter(job));
+ if (_queueFilterCache.filter === uploadSidebarFilter && _queueFilterCache.source === queueJobs && _queueFilterCache.result.length === filtered.length) {
+ let unchanged = true;
+ for (let index = 0; index < filtered.length; index++) {
+ if (_queueFilterCache.result[index] !== filtered[index]) {
+ unchanged = false;
+ break;
+ }
+ }
+ if (unchanged) return _queueFilterCache.result;
+ }
+ _queueFilterCache = { filter: uploadSidebarFilter, source: queueJobs, result: filtered };
+ return filtered;
+}
+
+function _normalizeQueueSelectionToVisible(visibleJobs = _getVisibleQueueJobs()) {
+ if (selectedJobIds.size === 0) return false;
+ const visibleIds = new Set(visibleJobs.map(job => job.id));
+ let changed = false;
+ for (const id of selectedJobIds) {
+ if (!visibleIds.has(id)) {
+ selectedJobIds.delete(id);
+ changed = true;
+ }
+ }
+ return changed;
+}
+
+function _getVisibleSelectedQueueJobs(predicate) {
+ const visibleJobs = _getVisibleQueueJobs();
+ _normalizeQueueSelectionToVisible(visibleJobs);
+ return visibleJobs.filter(job => selectedJobIds.has(job.id) && (!predicate || predicate(job)));
+}
+
+function renderQueueTable() {
+ const tbody = document.getElementById('queueBody');
+ if (!tbody) return;
+
+ const visibleJobs = _getVisibleQueueJobs();
+ const selectionChanged = _normalizeQueueSelectionToVisible(visibleJobs);
+ _sortedJobsCache = sortQueueJobs(visibleJobs);
+ if (selectionChanged) updateQueueActionButtons();
+ const totalRows = _sortedJobsCache.length;
+
+ if (totalRows < 200) {
+ // Try in-place update if row count matches (fast path)
+ const existingRows = tbody.querySelectorAll('.queue-row');
+ if (existingRows.length === totalRows && totalRows > 0) {
+ // In-place update – no DOM destruction
+ for (let i = 0; i < totalRows; i++) {
+ const tr = existingRows[i];
+ const job = _sortedJobsCache[i];
+ // If row identity changed (different job), fall back to full rebuild
+ if (tr.dataset.jobId !== job.id) {
+ tbody.innerHTML = _sortedJobsCache.map(buildRowHtml).join('');
+ _lastVisibleRange = { start: -1, end: -1 };
+ break;
+ }
+ _updateRowInPlace(tr, job);
+ }
+ } else {
+ // Full rebuild needed (row count changed)
+ tbody.innerHTML = _sortedJobsCache.map(buildRowHtml).join('');
+ _lastVisibleRange = { start: -1, end: -1 };
+ }
+ } else {
+ // Virtual scrolling for large queues — in-place update when range unchanged
+ _renderVirtualRows(tbody);
+ }
+
+ // Bind event delegation once
+ if (!_queueListenersBound) {
+ _queueListenersBound = true;
+ tbody.addEventListener('click', (e) => {
+ const row = e.target.closest('.queue-row');
+ if (row) handleRowClick(e, row);
+ });
+ tbody.addEventListener('contextmenu', (e) => {
+ const row = e.target.closest('.queue-row');
+ if (row) handleRowContextMenu(e, row);
+ });
+ }
+
+ // Update retry button visibility
+ const hasFailedJobs = queueJobs.some(j => j.status === 'error');
+ document.getElementById('retryFailedBtn').style.display = hasFailedJobs ? 'inline-block' : 'none';
+ updateQueueActionButtons();
+}
+
+function _renderVirtualRows(tbody) {
+ const scrollContainer = document.getElementById('queueContainer');
+ if (!scrollContainer) return;
+
+ const totalRows = _sortedJobsCache.length;
+ const scrollTop = scrollContainer.scrollTop;
+ // Use a minimum viewport height to avoid rendering nothing when container is being laid out
+ const viewportHeight = Math.max(scrollContainer.clientHeight, 200);
+
+ const startIdx = Math.max(0, Math.floor(scrollTop / VIRTUAL_ROW_HEIGHT) - VIRTUAL_OVERSCAN);
+ const endIdx = Math.min(totalRows, Math.ceil((scrollTop + viewportHeight) / VIRTUAL_ROW_HEIGHT) + VIRTUAL_OVERSCAN);
+
+ // Same range — try in-place update to avoid hover flicker
+ if (startIdx === _lastVisibleRange.start && endIdx === _lastVisibleRange.end) {
+ const rows = tbody.querySelectorAll('.queue-row');
+ if (rows.length === endIdx - startIdx) {
+ let allMatch = true;
+ for (let i = 0; i < rows.length; i++) {
+ const job = _sortedJobsCache[startIdx + i];
+ if (rows[i].dataset.jobId !== job.id) { allMatch = false; break; }
+ _updateRowInPlace(rows[i], job);
+ }
+ if (allMatch) return; // all rows updated in-place, no rebuild needed
+ }
+ }
+ _lastVisibleRange = { start: startIdx, end: endIdx };
+
+ const topPad = startIdx * VIRTUAL_ROW_HEIGHT;
+ const bottomPad = Math.max(0, (totalRows - endIdx) * VIRTUAL_ROW_HEIGHT);
+
+ let html = '';
+ if (topPad > 0) html += ` |
`;
+ for (let i = startIdx; i < endIdx; i++) {
+ html += buildRowHtml(_sortedJobsCache[i]);
+ }
+ if (bottomPad > 0) html += ` |
`;
+
+ tbody.innerHTML = html;
+}
+
+// Coalesce rapid scroll events (a fast trackpad fling fires dozens) into one
+// render per frame. rAF keeps the scroll thread cheap.
+let _queueScrollQueued = false;
+function _onQueueScroll() {
+ if (_queueScrollQueued) return;
+ if (_sortedJobsCache.length < 200) return;
+ _queueScrollQueued = true;
+ requestAnimationFrame(() => {
+ _queueScrollQueued = false;
+ const tbody = document.getElementById('queueBody');
+ if (tbody) _renderVirtualRows(tbody);
+ });
+}
+
+const _collatorDE = new Intl.Collator('de', { sensitivity: 'base', numeric: true });
+const _collatorSimple = new Intl.Collator('de');
+
+// Queue sort memoization. Keys that don't change after a job enters the queue
+// (filename, host) reuse the cached result across progress-driven re-renders.
+// Dynamic keys (status/speed/progress) AND size (which goes 0 → actual when
+// previews resolve / upload starts) are recomputed each call — otherwise a
+// queue sorted by size during previews would be stuck in all-zeros order.
+//
+// CRITICAL: the cache also tracks jobsRef (identity of the queueJobs array) so
+// that a full replacement (e.g. backup import, queue restore) invalidates the
+// cache. Length alone can match across a replace and would otherwise pin the
+// renderer to stale job references — the UI freezes showing old statuses even
+// though queueJobs itself has fresh objects. Observed as "upload runs in
+// status bar but all rows stay 'Bereit'" after importing a backup.
+let _queueSortCache = { sig: '', result: [], jobsRef: null };
+const _STATIC_SORT_KEYS = new Set(['filename', 'host']);
+
+// Dynamic-key sort throttle: status/speed/progress/size change on every
+// progress tick, so a strict per-call sort is O(N log N) per render. Within
+// one UI_UPDATE_INTERVAL window (200ms), reuse the previous sort even if it's
+// slightly out of order — the user can't perceive sub-200ms reorder lag, and
+// at 5000 queued jobs this is the difference between smooth and stuttering.
+// Uses lib/throttled-cache.js (see tests/throttled-cache.test.js).
+const DYNAMIC_SORT_REFRESH_MS = 200;
+const _dynamicSortCache = window.ThrottledCache
+ ? window.ThrottledCache.makeThrottledCache(DYNAMIC_SORT_REFRESH_MS)
+ : { get: () => undefined, set: (s, i, v) => v, clear: () => {} };
+
+function sortQueueJobs(jobs) {
+ const { key, direction } = queueSortState;
+ const factor = direction === 'asc' ? 1 : -1;
+ const canCache = _STATIC_SORT_KEYS.has(key);
+ const sig = canCache ? `${key}|${direction}|${jobs.length}` : '';
+ if (sig && _queueSortCache.sig === sig && _queueSortCache.jobsRef === jobs) {
+ return _queueSortCache.result;
+ }
+ // Dynamic-key throttle: same key+direction+array, sorted within the last
+ // 200ms → reuse. The cache is keyed by `key|direction` and uses the jobs
+ // array identity as the input ref, so a fresh queueJobs (e.g. after
+ // backup import) misses correctly.
+ if (!canCache) {
+ const dynSig = `${key}|${direction}`;
+ const cached = _dynamicSortCache.get(dynSig, jobs);
+ if (cached) return cached;
+ }
+
+ const sorted = jobs.slice().sort((a, b) => {
+ let cmp = 0;
+ if (key === 'filename') cmp = _collatorDE.compare(a.fileName, b.fileName);
+ else if (key === 'size') cmp = (a.bytesTotal || 0) - (b.bytesTotal || 0);
+ else if (key === 'host') cmp = _collatorSimple.compare(a.hoster, b.hoster);
+ else if (key === 'status') cmp = getStatusOrder(a.status) - getStatusOrder(b.status);
+ else if (key === 'speed') cmp = (a.speedKbs || 0) - (b.speedKbs || 0);
+ else if (key === 'progress') cmp = (a.progress || 0) - (b.progress || 0);
+ return cmp * factor;
+ });
+ if (sig) _queueSortCache = { sig, result: sorted, jobsRef: jobs };
+ else _dynamicSortCache.set(`${key}|${direction}`, jobs, sorted);
+ return sorted;
+}
+
+function getStatusOrder(status) {
+ const order = { uploading: 0, 'getting-server': 1, retrying: 2, queued: 3, preview: 4, done: 5, aborted: 6, error: 7, skipped: 8 };
+ return order[status] ?? 4;
+}
+
+// "Primär" / "Fallback #1" / "Fallback #2"… derived from the job's current
+// accountId position in the configured hoster account list. Returns '' if we
+// can't resolve it (e.g. account was removed mid-session).
+function getAccountLabel(job) {
+ if (!job || !job.accountId || !job.hoster) return '';
+ const accounts = config && config.hosters && config.hosters[job.hoster];
+ if (!Array.isArray(accounts)) return '';
+ const idx = accounts.findIndex(a => a && a.id === job.accountId);
+ if (idx < 0) return '';
+ return idx === 0 ? 'Primär' : `Fallback #${idx}`;
+}
+
+function getStatusText(job) {
+ const shortErr = job.error ? String(job.error).replace(/\s+/g, ' ').slice(0, 100) : '';
+ const acc = getAccountLabel(job);
+ const accSuffix = acc ? ` · ${acc}` : '';
+ switch (job.status) {
+ case 'preview': return 'Bereit';
+ case 'queued': return 'Wartet';
+ case 'getting-server': return `Server...${accSuffix}`;
+ case 'uploading': return `Upload${accSuffix}`;
+ case 'retrying': {
+ const base = `Retry ${job.attempt}/${job.maxAttempts}${accSuffix}`;
+ return shortErr ? `${base}: ${shortErr}` : base;
+ }
+ case 'done': return 'Fertig';
+ case 'aborted': return 'Abgebrochen';
+ case 'error': return shortErr ? `Fehlgeschlagen: ${shortErr}` : 'Fehlgeschlagen';
+ case 'skipped': return shortErr ? `Übersprungen: ${shortErr}` : 'Übersprungen';
+ default: return job.status;
+ }
+}
+
+// --- Queue interactions ---
+function handleRowClick(e, row) {
+ const jobId = row.dataset.jobId;
+ // Clear recent panel selection when clicking in queue — class-toggle only.
+ if (selectedRecentIds.size > 0) { selectedRecentIds.clear(); applyRecentSelectionClasses(); }
+
+ if (e.ctrlKey || e.metaKey) {
+ if (selectedJobIds.has(jobId)) selectedJobIds.delete(jobId);
+ else selectedJobIds.add(jobId);
+ } else if (e.shiftKey && selectedJobIds.size > 0) {
+ // Use sorted jobs cache for correct shift-click with virtual scrolling
+ const sortedIds = _sortedJobsCache.map(j => j.id);
+ const lastIdx = sortedIds.findIndex(id => selectedJobIds.has(id));
+ const curIdx = sortedIds.indexOf(jobId);
+ if (lastIdx >= 0 && curIdx >= 0) {
+ const from = Math.min(lastIdx, curIdx);
+ const to = Math.max(lastIdx, curIdx);
+ for (let i = from; i <= to; i++) selectedJobIds.add(sortedIds[i]);
+ }
+ } else {
+ selectedJobIds.clear();
+ selectedJobIds.add(jobId);
+ // Single click on done job -> copy link
+ const job = _jobIndexById.get(jobId);
+ if (job && job.status === 'done' && job.result) {
+ const link = job.result.download_url || job.result.embed_url || '';
+ if (link) {
+ window.api.copyToClipboard(link);
+ showCopyToast('Link kopiert');
+ }
+ }
+ }
+ // Selection changes don't change sort order / row content — just toggle classes.
+ applyQueueSelectionClasses();
+ updateQueueActionButtons();
+}
+
+// --- Context menu ---
+let alwaysOnTopState = false;
+
+// Cache hoster-counts for the context menu. Invalidated on structural changes
+// to queueJobs (the length-based signature is good enough — a job's hoster
+// never changes after it's created).
+let _hosterCountsCache = { sig: '', result: new Map() };
+function _getHosterCounts() {
+ const sig = `${queueJobs.length}`;
+ if (_hosterCountsCache.sig === sig) return _hosterCountsCache.result;
+ const m = new Map();
+ for (let i = 0; i < queueJobs.length; i++) {
+ const h = queueJobs[i].hoster;
+ m.set(h, (m.get(h) || 0) + 1);
+ }
+ _hosterCountsCache = { sig, result: m };
+ return m;
+}
+
+function handleRowContextMenu(e, row) {
+ e.preventDefault();
+ const jobId = row.dataset.jobId;
+ if (!selectedJobIds.has(jobId)) {
+ selectedJobIds.clear();
+ selectedJobIds.add(jobId);
+ applyQueueSelectionClasses();
+ updateQueueActionButtons();
+ }
+ showContextMenu(e.clientX, e.clientY);
+}
+
+function showContextMenu(x, y) {
+ const menu = document.getElementById('contextMenu');
+ // Update "Always on top" text
+ const aotItem = menu.querySelector('[data-action="always-on-top"]');
+ if (aotItem) aotItem.textContent = alwaysOnTopState ? 'Immer im Vordergrund ✓' : 'Immer im Vordergrund';
+ // Update labels with selection count
+ const n = selectedJobIds.size;
+ const delItem = menu.querySelector('[data-action="delete-selected"]');
+ if (delItem) delItem.textContent = n > 1 ? `Entfernen (${n})` : 'Entfernen';
+ const copyItem = menu.querySelector('[data-action="copy-links"]');
+ if (copyItem) copyItem.textContent = n > 1 ? `Links kopieren (${n})` : 'Link kopieren';
+ menu.querySelectorAll('[data-action="retry-selected"]').forEach(el => {
+ el.textContent = n > 1 ? `Erneut versuchen (${n})` : 'Erneut versuchen';
+ });
+ const startItem = menu.querySelector('[data-action="start-selected"]');
+ if (startItem) startItem.textContent = n > 1 ? `Ausgewählte starten (${n})` : 'Ausgewählte starten';
+
+ // Dynamic "delete by hoster" submenu — cached count keyed by queue length
+ // so a right-click on a 5000-job queue doesn't rescan everything.
+ const deleteHosterSubmenu = menu.querySelector('.ctx-hoster-delete-submenu');
+ const deleteHosterContainer = menu.querySelector('.ctx-hoster-delete-items');
+ const hosterCounts = _getHosterCounts();
+ deleteHosterContainer.innerHTML = '';
+ if (hosterCounts.size > 0) {
+ deleteHosterSubmenu.style.display = '';
+ hosterCounts.forEach((count, hoster) => {
+ const item = document.createElement('div');
+ item.className = 'ctx-item ctx-item-danger';
+ item.dataset.action = `delete-hoster:${hoster}`;
+ item.textContent = `${getHosterLabel(hoster)} (${count})`;
+ deleteHosterContainer.appendChild(item);
+ });
+ } else {
+ deleteHosterSubmenu.style.display = 'none';
+ }
+
+ menu.style.display = 'block';
+ const menuX = Math.min(x, window.innerWidth - menu.offsetWidth - 5);
+ menu.style.left = menuX + 'px';
+ menu.style.top = Math.min(y, window.innerHeight - menu.offsetHeight - 5) + 'px';
+
+ // Flip submenus if they would overflow the viewport right edge
+ menu.querySelectorAll('.ctx-submenu-items').forEach(sub => {
+ // Temporarily show to measure actual width (display:none → offsetWidth=0)
+ sub.style.visibility = 'hidden';
+ sub.style.display = 'block';
+ sub.classList.toggle('flip-left', menuX + menu.offsetWidth + sub.offsetWidth > window.innerWidth);
+ sub.style.display = '';
+ sub.style.visibility = '';
+ });
+}
+
+function hideContextMenu() {
+ document.getElementById('contextMenu').style.display = 'none';
+ document.getElementById('recentContextMenu').style.display = 'none';
+}
+
+function deleteSelectedRecentFiles() {
+ if (selectedRecentIds.size === 0) return;
+ let removedDone = 0, removedErr = 0;
+ sessionFilesData = sessionFilesData.filter(r => {
+ if (!selectedRecentIds.has(r.order)) return true;
+ if (r.isError) removedErr++; else removedDone++;
+ _sessionFileKeys.delete(`${r.link}\u0001${r.filename}\u0001${r.host}`);
+ return false;
+ });
+ _sessionDoneCount = Math.max(0, _sessionDoneCount - removedDone);
+ _sessionErrorCount = Math.max(0, _sessionErrorCount - removedErr);
+ _recentDataVersion++;
+ selectedRecentIds.clear();
+ renderRecentUploadsPanel();
+}
+
+function clearAllRecentFiles() {
+ if (sessionFilesData.length === 0) return;
+ if (!confirm(`Wirklich alle ${sessionFilesData.length} Links aus diesem Panel entfernen?`)) return;
+ sessionFilesData = [];
+ _sessionFileKeys.clear();
+ _sessionDoneCount = 0;
+ _sessionErrorCount = 0;
+ _recentDataVersion++;
+ selectedRecentIds.clear();
+ renderRecentUploadsPanel();
+}
+
+async function exportAllRecentFiles() {
+ if (sessionFilesData.length === 0) {
+ alert('Keine Einträge zum Exportieren.');
+ return;
+ }
+ const rows = sortRecentFiles(sessionFilesData);
+ const header = 'timestamp|hoster|link|filename|status';
+ const lines = rows.map(r => {
+ const ts = r.timestamp || r.time || '';
+ const host = r.host || r.hoster || '';
+ const link = r.link || '';
+ const name = r.filename || '';
+ const status = r.isError ? 'error' : 'ok';
+ return [ts, host, link, name, status].map(v => String(v).replace(/[\r\n|]/g, ' ')).join('|');
+ });
+ const content = [header, ...lines].join('\n') + '\n';
+ const defaultName = `uploads-${new Date().toISOString().slice(0, 10)}.log`;
+ try {
+ const result = await window.api.saveTextFile(defaultName, content, [
+ { name: 'Log-Datei', extensions: ['log', 'txt', 'csv'] }
+ ]);
+ if (result && result.ok) showCopyToast(`${rows.length} Einträge exportiert`);
+ } catch (err) {
+ alert('Export fehlgeschlagen: ' + (err.message || err));
+ }
+}
+
+function copySelectedRecentLinks() {
+ const links = sessionFilesData
+ .filter(r => selectedRecentIds.has(r.order) && !r.isError)
+ .map(r => r.link)
+ .filter(Boolean);
+ if (links.length) { window.api.copyToClipboard(links.join('\n')); showCopyToast(`${links.length} Links kopiert`); }
+}
+
+// --- Backup export / import ---
+async function doBackupExport() {
+ try {
+ await flushPendingSettingsSaves();
+ const result = await window.api.exportBackup();
+ if (result && result.ok) showCopyToast('Backup exportiert');
+ } catch (err) {
+ alert('Export fehlgeschlagen: ' + (err.message || err));
+ }
+}
+
+function applyImportedConfig(importedConfig, message) {
+ const pendingQueue = buildPersistedQueueState();
+ config = {
+ ...importedConfig,
+ globalSettings: {
+ ...(importedConfig.globalSettings || {}),
+ pendingQueue
+ }
+ };
+ hosterSettings = config.hosterSettings || {};
+ ensureAccountStatusEntries();
+ syncSelectedUploadHosters();
+ alwaysOnTopState = !!(config.globalSettings && config.globalSettings.alwaysOnTop);
+ renderSettings();
+ renderAccounts();
+ renderHosterSummary();
+ renderHosterModal();
+ loadHistory();
+ showCopyToast(message);
+}
+
+async function persistImportedQueueState() {
+ let persistenceError = null;
+ try {
+ await persistQueueStateNow();
+ } catch (error) {
+ persistenceError = error;
+ }
+ try {
+ await flushConfigWrites();
+ } catch (error) {
+ if (!persistenceError) persistenceError = error;
+ }
+ return persistenceError;
+}
+
+function showImportQueuePersistenceError(error) {
+ showCopyToast(`Import übernommen. Warteschlange konnte nicht vollständig gespeichert werden: ${error.message || error}`, 8000);
+}
+
+function setOnlineBackupStatus(message, state = '') {
+ const status = document.getElementById('onlineBackupStatus');
+ if (!status) return;
+ status.textContent = message;
+ status.dataset.state = state;
+}
+
+function setOnlineBackupBusy(busy) {
+ const createButton = document.getElementById('createOnlineBackupBtn');
+ const restoreButton = document.getElementById('restoreOnlineBackupBtn');
+ if (createButton) createButton.disabled = busy;
+ if (restoreButton) restoreButton.disabled = busy || !/^MHU2-[A-Za-z0-9_-]{70}$/.test(document.getElementById('onlineBackupKeyInput')?.value.trim() || '');
+}
+
+async function doOnlineBackupCreate() {
+ if (doOnlineBackupCreate.busy) return;
+ doOnlineBackupCreate.busy = true;
+ try {
+ await flushPendingSettingsSaves();
+ openOnlineBackupView();
+ } catch (error) {
+ openOnlineBackupView();
+ setOnlineBackupStatus(error.message || String(error), 'error');
+ doOnlineBackupCreate.busy = false;
+ return;
+ }
+ setOnlineBackupBusy(true);
+ setOnlineBackupStatus('Verschlüssele und speichere Einstellungen…', 'busy');
+ try {
+ const result = await window.api.createOnlineBackup();
+ if (!result || !result.ok) throw new Error(result?.error || 'Online-Sicherung konnte nicht erstellt werden');
+ const output = document.getElementById('onlineBackupKeyOutput');
+ const copyButton = document.getElementById('copyOnlineBackupKeyBtn');
+ if (output) output.value = result.key;
+ if (copyButton) copyButton.disabled = false;
+ setOnlineBackupStatus('Neuer Schlüssel erstellt. Ältere Schlüssel bleiben gültig.', 'success');
+ showCopyToast('Online-Schlüssel erstellt');
+ } catch (error) {
+ setOnlineBackupStatus(error.message || String(error), 'error');
+ } finally {
+ setOnlineBackupBusy(false);
+ doOnlineBackupCreate.busy = false;
+ }
+}
+
+function openOnlineBackupView(focusRestore = false) {
+ document.querySelector('.tab[data-view="settings"]')?.click();
+ const searchInput = document.getElementById('settingsSearchInput');
+ if (searchInput && searchInput.value) {
+ searchInput.value = '';
+ searchInput.dispatchEvent(new window.Event('input', { bubbles: true }));
+ }
+ document.querySelector('[data-settings-page="backup"]')?.click();
+ if (focusRestore) document.getElementById('onlineBackupKeyInput')?.focus();
+}
+
+function openOnlineBackupRestore() {
+ openOnlineBackupView(true);
+}
+
+async function doOnlineBackupRestore() {
+ const input = document.getElementById('onlineBackupKeyInput');
+ const key = input?.value.trim() || '';
+ if (!/^MHU2-[A-Za-z0-9_-]{70}$/.test(key)) {
+ setOnlineBackupStatus('Der Schlüssel muss mit MHU2- beginnen und exakt 75 Zeichen lang sein.', 'error');
+ input?.focus();
+ return;
+ }
+ setOnlineBackupBusy(true);
+ setOnlineBackupStatus('Speichere aktuelle Einstellungen…', 'busy');
+ try {
+ await flushPendingSettingsSaves();
+ setOnlineBackupStatus('Lade und entschlüssele Einstellungen…', 'busy');
+ beginConfigImport();
+ let result;
+ let queuePersistenceError = null;
+ try {
+ result = await window.api.restoreOnlineBackup(key);
+ if (result && result.ok) applyImportedConfig(result.config, 'Online-Backup importiert');
+ } finally {
+ queuePersistenceError = await persistImportedQueueState();
+ endConfigImport();
+ }
+ if (!result || !result.ok) throw new Error(result?.error || 'Online-Sicherung konnte nicht importiert werden');
+ const warnings = Array.isArray(result.warnings) ? result.warnings : [];
+ if (warnings.length) setOnlineBackupStatus(`Einstellungen übernommen. Bitte prüfen: ${warnings.join(', ')}.`, 'warning');
+ else setOnlineBackupStatus('Alle Accounts und Einstellungen wurden übernommen.', 'success');
+ if (queuePersistenceError) showImportQueuePersistenceError(queuePersistenceError);
+ } catch (error) {
+ setOnlineBackupStatus(error.message || String(error), 'error');
+ } finally {
+ setOnlineBackupBusy(false);
+ }
+}
+
+function askLegacyBackupPassword(hint) {
+ return new Promise((resolve) => {
+ const overlay = document.createElement('div');
+ overlay.className = 'modal-overlay';
+ overlay.style.display = 'flex';
+
+ const card = document.createElement('div');
+ card.className = 'modal-card';
+ card.style.width = 'min(380px,100%)';
+
+ const header = document.createElement('div');
+ header.className = 'modal-header';
+ const h3 = document.createElement('h3');
+ h3.textContent = 'Backup nicht entschlüsselbar';
+ header.appendChild(h3);
+
+ const body = document.createElement('div');
+ body.className = 'modal-body';
+ const p = document.createElement('p');
+ p.style.margin = '0 0 10px';
+ p.style.fontSize = '13px';
+ p.textContent = 'Wenn das Backup mit der alten Passwort-Option (vor v3.0) erstellt wurde, hier eingeben.';
+ if (hint) {
+ const p2 = document.createElement('p');
+ p2.style.margin = '0 0 10px';
+ p2.style.fontSize = '12px';
+ p2.style.color = 'var(--text-dim)';
+ p2.textContent = hint;
+ body.appendChild(p2);
+ }
+ const input = document.createElement('input');
+ input.type = 'password';
+ input.className = 'key-input';
+ input.placeholder = 'Passwort';
+ input.autocomplete = 'off';
+ input.style.width = '100%';
+ body.appendChild(p);
+ body.appendChild(input);
+
+ const footer = document.createElement('div');
+ footer.className = 'modal-footer';
+ const cancelBtn = document.createElement('button');
+ cancelBtn.className = 'btn btn-secondary';
+ cancelBtn.textContent = 'Abbrechen';
+ const okBtn = document.createElement('button');
+ okBtn.className = 'btn btn-primary';
+ okBtn.textContent = 'Importieren';
+ footer.appendChild(cancelBtn);
+ footer.appendChild(okBtn);
+
+ card.appendChild(header);
+ card.appendChild(body);
+ card.appendChild(footer);
+ overlay.appendChild(card);
+ document.body.appendChild(overlay);
+
+ const done = (val) => { overlay.remove(); resolve(val); };
+ okBtn.onclick = () => done(input.value || null);
+ cancelBtn.onclick = () => done(null);
+ input.addEventListener('keydown', (e) => {
+ if (e.key === 'Enter') done(input.value || null);
+ if (e.key === 'Escape') done(null);
+ });
+ input.focus();
+ });
+}
+
+async function doBackupImport(legacyPassword) {
+ const pw = typeof legacyPassword === 'string' ? legacyPassword : undefined;
+ try {
+ await flushPendingSettingsSaves();
+ beginConfigImport();
+ let result;
+ let queuePersistenceError = null;
+ try {
+ result = await window.api.importBackup(pw);
+ if (result && result.ok) applyImportedConfig(result.config, 'Backup importiert');
+ } finally {
+ queuePersistenceError = await persistImportedQueueState();
+ endConfigImport();
+ }
+ if (!result || result.canceled) return;
+ if (result.needsPassword) {
+ const entered = await askLegacyBackupPassword(result.hint);
+ if (entered) doBackupImport(entered);
+ return;
+ }
+ if (result.ok) {
+ if (Array.isArray(result.warnings) && result.warnings.length) {
+ alert(`Backup importiert. Bitte prüfen: ${result.warnings.join(', ')}.`);
+ }
+ if (queuePersistenceError) showImportQueuePersistenceError(queuePersistenceError);
+ } else if (result.error) {
+ alert('Import fehlgeschlagen: ' + result.error);
+ }
+ } catch (err) {
+ alert('Import fehlgeschlagen: ' + (err.message || err));
+ }
+}
+
+document.addEventListener('click', (e) => {
+ if (!e.target.closest('.context-menu')) hideContextMenu();
+});
+document.addEventListener('keydown', (e) => {
+ if (_isUpdateDialogVisible()) return;
+ const accountModal = document.getElementById('accountModal');
+ if (e.key === 'Tab' && accountModal && accountModal.style.display !== 'none') {
+ const focusable = Array.from(accountModal.querySelectorAll('button:not([disabled]), input:not([disabled]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex="-1"])'));
+ const first = focusable[0];
+ const last = focusable[focusable.length - 1];
+ if (first && last && ((!e.shiftKey && document.activeElement === last) || (e.shiftKey && document.activeElement === first))) {
+ e.preventDefault();
+ (e.shiftKey ? last : first).focus();
+ }
+ }
+ if (e.key === 'Escape') {
+ hideContextMenu();
+ cancelHosterModal();
+ if (accountModal && accountModal.style.display !== 'none') closeAccountModal();
+ }
+ if (e.target.closest('input, textarea, select')) return;
+ const activeView = document.querySelector('.view.active');
+ // Ctrl+A
+ if ((e.ctrlKey || e.metaKey) && e.key === 'a') {
+ if (activeView && activeView.id === 'upload-view') {
+ e.preventDefault();
+ // Select recent files only if user's last interaction was in the recent panel
+ if (selectedRecentIds.size > 0 && selectedJobIds.size === 0) {
+ sessionFilesData.forEach(r => selectedRecentIds.add(r.order));
+ renderRecentUploadsPanel();
+ } else {
+ const visibleJobs = _getVisibleQueueJobs();
+ selectedJobIds.clear();
+ visibleJobs.forEach(j => selectedJobIds.add(j.id));
+ renderQueueTable();
+ }
+ }
+ }
+ // Delete
+ if (e.key === 'Delete') {
+ if (activeView && activeView.id === 'upload-view') {
+ e.preventDefault();
+ _normalizeQueueSelectionToVisible();
+ if (selectedRecentIds.size > 0) {
+ deleteSelectedRecentFiles();
+ } else if (selectedJobIds.size > 0) {
+ const deletedIds = [...selectedJobIds];
+ // Cancel active uploads for deleted jobs
+ const activeIds = deletedIds.filter(id => {
+ const j = _jobIndexById.get(id);
+ return j && (j.status === 'uploading' || j.status === 'queued' || j.status === 'retrying' || j.status === 'getting-server');
+ });
+ if (activeIds.length > 0) window.api.cancelSelectedJobs(activeIds);
+ const _deletedKeys = [];
+ queueJobs = queueJobs.filter(j => {
+ if (selectedJobIds.has(j.id)) {
+ if (j.file && j.hoster && j.status !== 'done') _deletedKeys.push(`${j.file}|${j.hoster}`);
+ removeJobFromIndex(j);
+ return false;
+ }
+ return true;
+ });
+ selectedJobIds.clear();
+ syncSelectedFilesFromQueue();
+ suppressPreviewKeysStillSelected(_deletedKeys);
+ renderQueueTable();
+ if (queueJobs.length === 0) { selectedFiles = []; updateUploadView(); }
+ updateStatusBar();
+ persistQueueStateSoon(true);
+ }
+ }
+ }
+});
+
+document.getElementById('contextMenu').addEventListener('click', (e) => {
+ const item = e.target.closest('.ctx-item');
+ if (!item) return;
+ const action = item.dataset.action;
+ if (!action) return;
+ hideContextMenu();
+ handleContextAction(action);
+});
+
+async function handleContextAction(action) {
+ _normalizeQueueSelectionToVisible();
+ if (action === 'start-selected') {
+ startSelectedUpload();
+ } else if (action === 'copy-links') {
+ const links = getSelectedJobLinks();
+ if (links.length) { window.api.copyToClipboard(links.join('\n')); showCopyToast(`${links.length} Links kopiert`); }
+ } else if (action === 'retry-selected') {
+ retrySelectedJobs();
+ } else if (action === 'show-log') {
+ showJobLogModal();
+ } else if (action === 'delete-selected') {
+ // Cancel active uploads for deleted jobs
+ const activeIds = [...selectedJobIds].filter(id => {
+ const j = _jobIndexById.get(id);
+ return j && (j.status === 'uploading' || j.status === 'queued' || j.status === 'retrying' || j.status === 'getting-server');
+ });
+ if (activeIds.length > 0) window.api.cancelSelectedJobs(activeIds);
+ const _deletedKeys = [];
+ queueJobs = queueJobs.filter(j => {
+ if (selectedJobIds.has(j.id)) {
+ if (j.file && j.hoster && j.status !== 'done') _deletedKeys.push(`${j.file}|${j.hoster}`);
+ removeJobFromIndex(j);
+ return false;
+ }
+ return true;
+ });
+ selectedJobIds.clear();
+ syncSelectedFilesFromQueue();
+ suppressPreviewKeysStillSelected(_deletedKeys);
+ renderQueueTable();
+ if (queueJobs.length === 0) { selectedFiles = []; updateUploadView(); }
+ updateStatusBar();
+ persistQueueStateSoon(true);
+ } else if (action === 'copy-all-links') {
+ copyAllLinks();
+ } else if (action === 'delete-all') {
+ // Cancel all active uploads
+ const activeIds = queueJobs
+ .filter(j => j.status === 'uploading' || j.status === 'queued' || j.status === 'retrying' || j.status === 'getting-server')
+ .map(j => j.id);
+ if (activeIds.length > 0) window.api.cancelSelectedJobs(activeIds);
+ queueJobs.forEach(j => removeJobFromIndex(j));
+ queueJobs = [];
+ selectedJobIds.clear();
+ selectedFiles = [];
+ syncSelectedFilesFromQueue();
+ renderQueueTable();
+ updateUploadView();
+ updateStatusBar();
+ persistQueueStateSoon(true);
+ } else if (action === 'always-on-top') {
+ alwaysOnTopState = !alwaysOnTopState;
+ await setAlwaysOnTopTracked(alwaysOnTopState);
+ config.globalSettings = { ...(config.globalSettings || {}), alwaysOnTop: alwaysOnTopState };
+ } else if (action.startsWith('delete-hoster:')) {
+ const hoster = action.replace('delete-hoster:', '');
+ // Cancel active uploads for this hoster
+ const activeIds = queueJobs
+ .filter(j => j.hoster === hoster && (j.status === 'uploading' || j.status === 'queued' || j.status === 'retrying' || j.status === 'getting-server' || j.status === 'preview'))
+ .map(j => j.id);
+ if (activeIds.length > 0) await window.api.cancelSelectedJobs(activeIds);
+ // Remove ALL jobs for this hoster
+ queueJobs = queueJobs.filter(j => {
+ if (j.hoster === hoster) { removeJobFromIndex(j); return false; }
+ return true;
+ });
+ selectedJobIds.clear();
+ syncSelectedFilesFromQueue();
+ renderQueueTable();
+ if (queueJobs.length === 0) { selectedFiles = []; updateUploadView(); }
+ updateStatusBar();
+ updateQueueActionButtons();
+ persistQueueStateSoon(true);
+ } else if (action.startsWith('shutdown-')) {
+ const mode = action.replace('shutdown-', '');
+ await window.api.setShutdownAfterFinish(mode);
+ }
+}
+
+function getSelectedJobLinks() {
+ return _getVisibleSelectedQueueJobs(j => j.status === 'done' && j.result)
+ .map(j => j.result.download_url || j.result.embed_url || '')
+ .filter(Boolean);
+}
+
+// --- Upload ---
+async function startUpload(opts) {
+ if (uploading) return;
+ if (!(opts && opts._autoRetry)) _cancelAutoRetry(true);
+ else _cancelAutoRetry(false);
+ uploading = true; // set immediately to prevent double-click race
+ updateQueueActionButtons();
+ _hydrateMissingJobSizes();
+
+ const hosters = getSelectedHosters();
+ if (queueJobs.length === 0 && selectedFiles.length > 0) {
+ if (hosters.length === 0) {
+ alert('Bitte mindestens einen Hoster auswählen.');
+ uploading = false;
+ updateQueueActionButtons();
+ return;
+ }
+ buildQueuePreview();
+ }
+
+ const jobsToStart = queueJobs.filter((job) => isStartableQueueStatus(job.status));
+ if (jobsToStart.length === 0) { uploading = false; updateQueueActionButtons(); return; }
+
+ try {
+ jobsToStart.forEach(j => {
+ j.status = 'queued';
+ j.error = null;
+ j.result = null;
+ j.bytesUploaded = 0;
+ j.speedKbs = 0;
+ j.elapsed = 0;
+ j.remaining = 0;
+ j.progress = 0;
+ j.uploadId = null;
+ });
+ updateQueueActionButtons();
+ renderQueueTable();
+ updateStatusBar();
+
+ const uploadPayload = {
+ hosters,
+ isAutoRetry: !!(opts && opts._autoRetry),
+ jobs: jobsToStart.map((job) => ({
+ id: job.id,
+ file: job.file,
+ fileName: job.fileName,
+ hoster: job.hoster
+ }))
+ };
+ const result = await window.api.startUpload(uploadPayload);
+ _markSkippedJobs(result);
+ persistQueueStateSoon();
+
+ if (result && result.error) {
+ alert(result.error);
+ uploading = false;
+ updateQueueActionButtons();
+ updateStatusBar();
+ }
+ } catch (err) {
+ uploading = false;
+ updateQueueActionButtons();
+ updateStatusBar();
+ alert(`Upload-Start fehlgeschlagen: ${err.message}`);
+ }
+}
+
+function _markSkippedJobs(result) {
+ if (!result || !Array.isArray(result.skippedJobs) || result.skippedJobs.length === 0) return;
+ for (const skipped of result.skippedJobs) {
+ const job = _jobIndexById.get(skipped.jobId);
+ if (job) {
+ job.status = 'error';
+ job.error = skipped.reason || 'Kein gültiger Account';
+ }
+ }
+ renderQueueTable();
+}
+
+async function startSelectedUpload(explicitJobs) {
+ const scopedJobs = Array.isArray(explicitJobs) ? explicitJobs : _getVisibleSelectedQueueJobs();
+ if (uploading) {
+ _hydrateMissingJobSizes();
+ const addable = scopedJobs.filter(j => isStartableQueueStatus(j.status));
+ if (addable.length === 0) {
+ if (selectedJobIds.size > 0) showCopyToast('Keine startbaren Jobs ausgewählt (alle laufen schon oder sind fertig).');
+ return;
+ }
+ {
+ addable.forEach(j => {
+ j.status = 'queued'; j.error = null; j.result = null;
+ j.bytesUploaded = 0; j.speedKbs = 0; j.progress = 0; j.uploadId = null;
+ });
+ renderQueueTable();
+ let result = null;
+ try {
+ result = await window.api.addJobsToBatch({
+ jobs: addable.map(j => ({ id: j.id, file: j.file, fileName: j.fileName, hoster: j.hoster }))
+ });
+ } catch (err) {
+ showCopyToast(`Jobs konnten nicht hinzugefuegt werden: ${err.message}`);
+ return;
+ }
+
+ // If the batch ended between UI-state and IPC call, start a fresh batch immediately
+ if (result && result.error === 'Kein Upload aktiv') {
+ uploading = false;
+ updateQueueActionButtons();
+ updateStatusBar();
+ await startSelectedUpload(addable);
+ return;
+ }
+ _markSkippedJobs(result);
+ persistQueueStateSoon();
+ const added = Number(result && result.added) || 0;
+ // Use ASCII-only toast text here to avoid encoding artifacts on some systems.
+ const skipped = Array.isArray(result && result.skippedJobs) ? result.skippedJobs.length : 0;
+ const alreadyInBatch = Array.isArray(result && result.alreadyInBatchJobIds)
+ ? result.alreadyInBatchJobIds.length
+ : Math.max(0, addable.length - added - skipped);
+ const toastParts = [];
+ if (added > 0) toastParts.push(`${added} hinzugefuegt`);
+ if (alreadyInBatch > 0) toastParts.push(`${alreadyInBatch} bereits im Batch`);
+ if (skipped > 0) toastParts.push(`${skipped} ohne gueltigen Account`);
+ if (result && result.error) {
+ showCopyToast(`Jobs konnten nicht hinzugefuegt werden: ${result.error}`);
+ } else if (toastParts.length > 0) {
+ showCopyToast(`Jobs: ${toastParts.join(', ')}`);
+ } else {
+ showCopyToast('Keine Jobs hinzugefuegt');
+ }
+ return;
+ }
+ }
+ uploading = true; // set immediately to prevent double-click race
+ updateQueueActionButtons();
+
+ const hosters = getSelectedHosters();
+ const jobsToStart = scopedJobs.filter(job => isStartableQueueStatus(job.status));
+ if (jobsToStart.length === 0) { uploading = false; updateQueueActionButtons(); return; }
+
+ try {
+ jobsToStart.forEach(j => {
+ j.status = 'queued';
+ j.error = null;
+ j.result = null;
+ j.bytesUploaded = 0;
+ j.speedKbs = 0;
+ j.progress = 0;
+ j.uploadId = null;
+ });
+ updateQueueActionButtons();
+ renderQueueTable();
+ updateStatusBar();
+
+ const uploadPayload = {
+ hosters,
+ jobs: jobsToStart.map((job) => ({
+ id: job.id,
+ file: job.file,
+ fileName: job.fileName,
+ hoster: job.hoster
+ }))
+ };
+ const result = await window.api.startUpload(uploadPayload);
+ _markSkippedJobs(result);
+ persistQueueStateSoon();
+
+ if (result && result.error) {
+ alert(result.error);
+ uploading = false;
+ updateQueueActionButtons();
+ updateStatusBar();
+ }
+ } catch (err) {
+ uploading = false;
+ updateQueueActionButtons();
+ updateStatusBar();
+ alert(`Upload-Start fehlgeschlagen: ${err.message}`);
+ }
+}
+
+async function cancelUpload() {
+ _cancelAutoRetry(true);
+ await window.api.cancelUpload();
+ uploading = false;
+ // Reset all non-finished jobs back to queued state
+ for (const job of queueJobs) {
+ if (!['done', 'error', 'skipped'].includes(job.status)) {
+ job.status = 'queued';
+ job.progress = 0;
+ job.bytesUploaded = 0;
+ job.speedKbs = 0;
+ job.elapsed = 0;
+ job.remaining = 0;
+ job.error = null;
+ }
+ }
+ renderQueueTable();
+ updateQueueActionButtons();
+ updateStatusBar();
+ persistQueueStateSoon();
+}
+
+// --- Progress handling ---
+function handleProgress(data) {
+ try {
+ if (!data || typeof data !== 'object') return;
+ _handleProgressImpl(data);
+ } catch (err) {
+ if (window.api && window.api.debugLog) window.api.debugLog(`handleProgress error: ${err && err.stack ? err.stack : err}`);
+ }
+}
+function _handleProgressImpl(data) {
+ let job = data.jobId ? _jobIndexById.get(data.jobId) : null;
+ if (!job && data.uploadId) job = _jobIndexByUploadId.get(data.uploadId);
+ if (!job) {
+ job = queueJobs.find(j =>
+ j.fileName === data.fileName && j.hoster === data.hoster && j.status === 'queued'
+ ) || queueJobs.find(j =>
+ j.fileName === data.fileName && j.hoster === data.hoster && j.status === 'preview'
+ );
+ if (job && data.uploadId) {
+ job.uploadId = data.uploadId;
+ _jobIndexByUploadId.set(data.uploadId, job);
+ }
+ }
+ if (!job) {
+ // Don't re-create jobs that were explicitly deleted by the user
+ if ((data.jobId && _deletedJobIds.has(data.jobId)) || (data.uploadId && _deletedJobIds.has(data.uploadId))) {
+ return;
+ }
+ job = {
+ id: data.jobId || data.uploadId || `job-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+ uploadId: data.uploadId,
+ file: '', fileName: data.fileName, hoster: data.hoster,
+ status: data.status, bytesUploaded: 0, bytesTotal: data.bytesTotal || 0,
+ speedKbs: 0, elapsed: 0, remaining: 0,
+ error: null, result: null, attempt: 0, maxAttempts: 0, link: ''
+ };
+ queueJobs.push(job);
+ indexJob(job);
+ }
+
+ // Don't regress from terminal states (stale callbacks can arrive after completion)
+ if (job.status === 'done' || job.status === 'skipped') return;
+
+ // Update job state
+ job.status = data.status;
+ job.bytesUploaded = data.bytesUploaded || 0;
+ job.bytesTotal = data.bytesTotal || job.bytesTotal;
+ // Track session total bytes (survives removeFromQueueOnDone)
+ if (job.bytesTotal > 0 && !_sessionTrackedJobs.has(job.id)) {
+ _sessionTotalBytes += job.bytesTotal;
+ _sessionTrackedJobs.add(job.id);
+ }
+ job.speedKbs = data.speedKbs || 0;
+ job.elapsed = data.elapsed || 0;
+ job.remaining = data.remaining || 0;
+ job.error = data.error || null;
+ job.result = data.result || job.result;
+ job.attempt = data.attempt || 0;
+ job.maxAttempts = data.maxAttempts || 0;
+ job.progress = data.progress || 0;
+ // Track which account the backend is currently using so the status cell
+ // can display "Primär" vs "Fallback #N" during rotation.
+ if (data.accountId) job.accountId = data.accountId;
+ if (data.uploadId) {
+ job.uploadId = data.uploadId;
+ _jobIndexByUploadId.set(data.uploadId, job);
+ }
+
+ maybeAddSessionFile(job);
+
+ // Track session uploaded bytes (survives removeFromQueueOnDone)
+ if (job.status === 'done' && !_sessionDoneJobs.has(job.id)) {
+ _sessionUploadedBytes += job.bytesTotal || 0;
+ _sessionDoneJobs.add(job.id);
+ }
+
+ // Track completed uploads so they don't get re-queued after removal
+ if (job.status === 'done') {
+ _completedUploadKeys.add(`${job.file}|${job.hoster}`);
+ }
+
+ // Remove finished jobs from queue if setting is enabled. Coalesce the
+ // actual array filter into one microtask: a burst of 500 done events
+ // would otherwise fire 500 individual O(N) filters = O(N²) work, visible
+ // as a brief UI freeze when a big batch finishes. Index/selection are
+ // updated synchronously so subsequent lookups see the right state — only
+ // the array rewrite is deferred.
+ if (job.status === 'done' && config.globalSettings && config.globalSettings.removeFromQueueOnDone) {
+ removeJobFromIndex(job, true);
+ selectedJobIds.delete(job.id);
+ if (_doneRemovalCoalescer) {
+ _doneRemovalCoalescer.add(job.id);
+ } else {
+ // Legacy slow path: immediate filter when the lib script didn't load.
+ queueJobs = queueJobs.filter(j => j !== job);
+ }
+ }
+
+ // Status changes (done/error/etc) get one coalesced update per frame so a
+ // burst of 500 parallel jobs flipping state doesn't fire 2000 sync DOM
+ // updates. Ongoing uploading progress is throttled at 200ms.
+ if (data.status === 'uploading') {
+ scheduleThrottledUIUpdate();
+ } else {
+ scheduleStatusChangeUpdate();
+ }
+ persistQueueStateSoon();
+}
+
+function handleBatchDone(summary) {
+ uploading = false;
+ applySummaryResults(summary);
+ _deletedJobIds.clear(); // Free memory — stale IDs no longer needed after batch completes
+ // Prune session-stats sets to current queue contents. Without this, IDs
+ // of jobs that were removed from queueJobs (via removeFromQueueOnDone
+ // or the cap-prune below) live forever in these sets — small leak per
+ // entry, real over weeks of use. _completedUploadKeys is intentionally
+ // kept (it's the dedup against re-queueing the same file).
+ if (_sessionTrackedJobs.size > 0 || _sessionDoneJobs.size > 0) {
+ const aliveIds = new Set();
+ for (const j of queueJobs) aliveIds.add(j.id);
+ for (const id of _sessionTrackedJobs) if (!aliveIds.has(id)) _sessionTrackedJobs.delete(id);
+ for (const id of _sessionDoneJobs) if (!aliveIds.has(id)) _sessionDoneJobs.delete(id);
+ }
+
+ // Reset aborted jobs back to queued so they can be restarted
+ for (const job of queueJobs) {
+ if (job.status === 'aborted') {
+ job.status = 'queued';
+ job.progress = 0;
+ job.bytesUploaded = 0;
+ job.speedKbs = 0;
+ job.elapsed = 0;
+ job.remaining = 0;
+ job.error = null;
+ }
+ }
+
+ syncSelectedFilesFromQueue();
+ updateQueueActionButtons();
+ renderQueueTable();
+ renderRecentUploadsPanel();
+ // History is only visible on the Verlauf tab. Mark it dirty and refresh when
+ // the user actually switches to it — skips an IPC + full table rebuild per
+ // batch-done when the user is watching the upload view.
+ _historyDirty = true;
+ if (_isHistoryTabActive()) loadHistory();
+
+ const removeOnDone = config.globalSettings && config.globalSettings.removeFromQueueOnDone;
+ if (removeOnDone) {
+ // Single pass: build the keep-list and clean up the index for removed jobs.
+ const nextJobs = [];
+ for (const job of queueJobs) {
+ if (job.status === 'done') {
+ removeJobFromIndex(job, true);
+ selectedJobIds.delete(job.id);
+ } else {
+ nextJobs.push(job);
+ }
+ }
+ queueJobs = nextJobs;
+ renderQueueTable();
+ } else {
+ // Auto-prune for the default (removeOnDone=false) too: cap terminal
+ // jobs (done/skipped/error/aborted) at the most recent N so the queue
+ // can't grow unbounded across long sessions. The algorithm lives in
+ // lib/queue-prune.js (same impl Node-tested, see tests/queue-prune.test.js)
+ // and the result tells us which jobs to drop so we can clean up the
+ // index + selection in one pass.
+ const TERMINAL_KEEP_LIMIT = 500;
+ // Optional-chain so the renderer still works if the prune script fails
+ // to load (e.g. file:// path issues during dev) — falls back to no-prune
+ // rather than crashing on every batch-done.
+ const result = window.QueuePrune?.pruneOldestTerminalJobs(queueJobs, TERMINAL_KEEP_LIMIT);
+ if (result) {
+ for (const j of result.dropped) {
+ removeJobFromIndex(j, true);
+ selectedJobIds.delete(j.id);
+ }
+ queueJobs = result.kept;
+ renderQueueTable();
+ }
+ }
+
+ if (queueJobs.some((job) => !['done', 'skipped'].includes(job.status))) persistQueueStateSoon(true);
+ else clearPersistedQueueStateSoon();
+
+ lastUploadStats = { state: 'idle', globalSpeedKbs: 0, totalBytes: lastUploadStats.totalBytes, elapsed: lastUploadStats.elapsed, activeJobs: 0 };
+ updateStatusBar();
+ _refreshSessionFailedSnapshot();
+ _scheduleAutoRetryIfNeeded();
+}
+
+let _sessionFailedKeys = new Set();
+
+const _autoRetryState = { round: 0, timer: null };
+function _cancelAutoRetry(resetRound) {
+ if (_autoRetryState.timer) { clearTimeout(_autoRetryState.timer); _autoRetryState.timer = null; }
+ if (resetRound) _autoRetryState.round = 0;
+}
+function _collectAutoRetryableJobs() {
+ if (!window.Stats) return [];
+ return queueJobs.filter(j => j.status === 'error'
+ && window.Stats.isRetryableCategory(window.Stats.classifyErrorCategory(j.error)));
+}
+function _scheduleAutoRetryIfNeeded() {
+ const rounds = Math.max(0, Math.min(5, Number(config.globalSettings?.autoRetryRounds) || 0));
+ if (rounds <= 0) return;
+ if (_autoRetryState.round >= rounds) { _autoRetryState.round = 0; return; }
+ const retryable = _collectAutoRetryableJobs();
+ if (retryable.length === 0) { _autoRetryState.round = 0; return; }
+ const delayMin = Math.max(1, Math.min(120, Number(config.globalSettings?.autoRetryDelayMin) || 5));
+ const nextRound = _autoRetryState.round + 1;
+ const waitMin = delayMin * nextRound;
+ _autoRetryState.round = nextRound;
+ showCopyToast(`Auto-Retry Runde ${nextRound}/${rounds}: ${retryable.length} transiente Fehler werden in ${waitMin} min neu versucht.`, 10000);
+ _autoRetryState.timer = setTimeout(() => {
+ _autoRetryState.timer = null;
+ const jobs = _collectAutoRetryableJobs();
+ if (jobs.length === 0) { _autoRetryState.round = 0; return; }
+ for (const j of jobs) {
+ j.status = 'queued'; j.error = null; j.result = null;
+ j.bytesUploaded = 0; j.speedKbs = 0; j.progress = 0; j.uploadId = null;
+ }
+ renderQueueTable();
+ startUpload({ _autoRetry: true });
+ }, waitMin * 60_000);
+}
+async function _refreshSessionFailedSnapshot() {
+ if (!window.api || !window.api.getSessionFailedAccounts) return;
+ try {
+ const keys = await window.api.getSessionFailedAccounts();
+ _sessionFailedKeys = new Set(Array.isArray(keys) ? keys : []);
+ renderAccounts();
+ } catch { /* ignore */ }
+}
+
+function _maybeShowBatchSummary(summary) {
+ if (!window.Stats || !summary) return;
+ const buckets = window.Stats.summarizeBatchErrors(summary);
+ const total = Object.values(buckets).reduce((n, arr) => n + arr.length, 0);
+ if (total === 0) return;
+
+ const modal = document.getElementById('batchSummaryModal');
+ if (!modal) return;
+ const list = modal.querySelector('#batchSummaryList');
+ const retryAllBtn = modal.querySelector('#batchSummaryRetryAll');
+ const retryTransientBtn = modal.querySelector('#batchSummaryRetryTransient');
+ const closeBtn = modal.querySelector('#batchSummaryClose');
+
+ const order = ['hoster-transient', 'network', 'unknown', 'file-rejected', 'account-error', 'aborted'];
+ list.innerHTML = order
+ .filter(cat => buckets[cat].length > 0)
+ .map(cat => {
+ const items = buckets[cat];
+ const sample = items.slice(0, 3).map(i => `${escapeHtml(i.fileName)} → ${escapeHtml(i.hoster)}: ${escapeHtml(i.error)}`).join('');
+ const more = items.length > 3 ? `… +${items.length - 3} weitere` : '';
+ const retryable = window.Stats.isRetryableCategory(cat);
+ const tag = retryable ? 'erneut versuchbar' : 'manuell';
+ return `
+
${escapeHtml(window.Stats.CATEGORY_LABELS[cat] || cat)} ${items.length} ${tag}
+
+
+ ${escapeHtml(label)}
+ ${escapeHtml(p) || ''}
+
+
`;
+ }).join('');
+ el.querySelectorAll('[data-reveal-log]').forEach(btn => {
+ btn.addEventListener('click', () => {
+ const target = btn.getAttribute('data-reveal-log');
+ if (window.api && window.api.revealLogFile) window.api.revealLogFile(target).catch(() => {});
+ });
+ });
+ } catch (err) {
+ el.innerHTML = `Fehler: ${escapeHtml(err.message || String(err))}`;
+ }
+}
+
+function renderSettings() {
+ const container = document.getElementById('settingsHosters');
+ container.innerHTML = '';
+
+ const globalSettings = config.globalSettings || {};
+ const configuredAccounts = getAvailableHosters();
+ const fm = globalSettings.folderMonitor || {};
+ const remoteSettings = globalSettings.remote || {};
+
+ const pageDefinitions = [
+ { id: 'allgemein', label: 'Allgemein', search: 'fenster vordergrund drop target oberfläche updates aktualisierung version' },
+ { id: 'uploads', label: 'Uploads', search: 'upload queue warteschlange fertig abschluss entfernen parallel geschwindigkeit speed limit fortsetzen wiederherstellen hoster' },
+ { id: 'automatik', label: 'Automatik', search: 'automatisch retry wiederholen ordner überwachen dateierweiterungen unterordner duplikate' },
+ { id: 'benachrichtigungen', label: 'Benachrichtigungen', search: 'webhook discord meldung ping erwähnung batch fertig' },
+ { id: 'logs', label: 'Logs & Support', search: 'log protokoll debug verbose diagnose support paket datei ordner' },
+ { id: 'remote', label: 'Fernsteuerung', search: 'remote fernsteuerung server input port api token verbindung' },
+ { id: 'diagnose', label: 'Diagnose-Zugriff', search: 'diagnose zugriff lesen allowlist netzwerk lokal verbindung code support' },
+ { id: 'backup', label: 'Backup & Übertragen', search: 'backup sichern export import online schlüssel einstellungen accounts übertragen' }
+ ];
+ const pageHeader = (title, description) => `
+ `;
+
+ const layout = document.createElement('div');
+ layout.className = 'settings-layout';
+ layout.innerHTML = `
+
+ `;
+ container.appendChild(layout);
+
+ const navigation = layout.querySelector('.settings-navigation');
+ const content = layout.querySelector('.settings-content');
+ const pages = {};
+ pageDefinitions.forEach(({ id }) => {
+ const page = document.createElement('div');
+ page.className = id === 'allgemein' ? 'settings-subpage active' : 'settings-subpage';
+ page.dataset.subpage = id;
+ pages[id] = page;
+ content.appendChild(page);
+ });
+
+ pages.allgemein.innerHTML = `
+ ${pageHeader('Allgemein', 'Fensterverhalten, Drop-Target und Programmupdates.')}
+ Oberfläche
+
+ Programmupdate
+
+
+
+
+ `;
+
+ pages.uploads.innerHTML = `
+ ${pageHeader('Upload-Verhalten', 'Globale Leistung, Warteschlange und Verhalten nach einem erfolgreichen Upload.')}
+ Leistung
+
+
+
+ 0 = nur die Einstellung des jeweiligen Hosters verwenden
+
+
+
+
+ MB/s · 0 = unbegrenzt
+
+
+
+
+ Verteilt die globale Parallelität auf vorhandene Accounts eines Hosters.
+
+
+
Warteschlange
+
+
+
+ Erfolgreich hochgeladene Dateien verschwinden automatisch aus der Upload-Liste.
+
+
+
+
+
+ Noch nicht abgeschlossene Uploads werden beim nächsten Programmstart erneut angezeigt.
+
+
+
Einstellungen einzelner Hoster wie Wiederholungen, Geschwindigkeit, Parallelität, Dateigröße und Logging findest du im Accounts-Tab direkt beim jeweiligen Hoster.
+ `;
+
+ pages.automatik.innerHTML = `
+ ${pageHeader('Automatik', 'Wiederholungen und überwachte Ordner für unbeaufsichtigte Uploads.')}
+ Unbeaufsichtigter Betrieb
+
+
+
+ 0 = aus. Nach Batch-Ende werden transiente Fehler (Netzwerk, Hoster-Flake) automatisch bis zu N Runden neu versucht.
+
+
+
+
+ Minuten · jede weitere Runde wartet entsprechend länger
+
+ Ordnerüberwachung ${fm.enabled && fm.folderPath ? 'Aktiv' : 'Inaktiv'}
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Warten bis Datei fertig geschrieben
+
+ Verhalten
+
+ Hoster-Vorauswahl
+
+ ${configuredAccounts.map(({ name }) => `
+
+
+
+
`).join('')}
+
Erst Accounts anlegen, dann hier auswählen.
' : 'Keine Auswahl = Hoster-Modal bei jeder Datei.
'}
+ `;
+
+ pages.benachrichtigungen.innerHTML = `
+ ${pageHeader('Benachrichtigungen', 'Meldungen nach einem abgeschlossenen Upload-Batch versenden.')}
+ Webhook
+
+
+
+
+ Nach Batch-Ende wird eine Zusammenfassung versendet. Discord wird automatisch erkannt, andere Ziele erhalten JSON.
+
+
+
+
+ Optional · leer lassen, wenn die Nachricht ohne Ping gesendet werden soll
+
+ `;
+
+ pages.logs.innerHTML = `
+ ${pageHeader('Logs & Support', 'Protokollierung verwalten, Log-Dateien öffnen und ein bereinigtes Support-Paket erstellen.')}
+ Log
+
+
+
+
+
+
+
+
+
+ Pro Session = neue Datei bei jedem App-Start; nach komplettem Schließen + erneutem Öffnen beginnt eine neue Session.
+
+
+
+
+
+ Diagnose
+
+
+
+ Wird geladen…
+
+
+
+
+ Eine .txt mit Logs + sanitierter Config; Passwörter/API-Keys werden vor dem Speichern maskiert.
+
+ `;
+
+ pages.remote.innerHTML = `
+ ${pageHeader('Fernsteuerung', 'Upload-Funktionen über einen verbundenen Client steuern.')}
+ Server ${remoteSettings.enabled ? 'Aktiv' : 'Inaktiv'}
+
+
+
+
+
+
+
+
+
+
+
+ Status
+
+ Prüfe...
+
+ `;
+
+ pages.diagnose.innerHTML = `
+ ${pageHeader('Diagnose-Zugriff', 'Zeitlich kontrollierter Lesezugriff für Fehleranalyse und Support.')}
+ Diagnose-Zugriff (nur lesen) …
+
+ Erlaubt nur lesenden Zugriff auf Logs, Queue-Status und bereinigte Einstellungen. Passwörter, API-Keys und Tokens werden maskiert. Bildschirm und Eingabesteuerung bleiben gesperrt. Der Verbindungs-Code ist ein Zugangsschlüssel — nur mit vertrauenswürdigen Stellen teilen; bei Verdacht „Neu" klicken. Standard-Bindung ist 127.0.0.1 und damit nur über einen SSH- oder VPN-Tunnel erreichbar.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Status
+
+ Prüfe…
+
+ `;
+
+ pages.backup.innerHTML = `
+ ${pageHeader('Backup & Übertragen', 'Accounts und Einstellungen sichern oder auf ein anderes Gerät übernehmen.')}
+ Der Upload-Verlauf wird nicht übertragen und bleibt auf diesem Gerät.
+
+
+
Verschlüsseltes Online-Backup
+
Die Verschlüsselung findet ausschließlich auf diesem Gerät statt. Der Server speichert nur verschlüsselte Daten.
+
+
+ Jeder Export erzeugt einen neuen Schlüssel. Ältere Schlüssel bleiben gültig.
+
+
+
+
+
+
+
+
+
+
+
+ Behandle den Schlüssel wie ein Passwort. Wer ihn besitzt, kann die verschlüsselten Einstellungen entschlüsseln.
+
+
+ Lokales Datei-Backup
+
+
+
+
+ `;
+
+ const activateSettingsPage = (target, focus = false) => {
+ const activeButton = navigation.querySelector(`[data-settings-page="${target}"]`);
+ if (!activeButton || activeButton.hidden) return;
+ navigation.querySelectorAll('.settings-nav-button').forEach((button) => {
+ const active = button === activeButton;
+ button.classList.toggle('active', active);
+ button.setAttribute('aria-current', active ? 'page' : 'false');
+ });
+ Object.values(pages).forEach((page) => {
+ page.classList.toggle('active', page.dataset.subpage === target);
+ });
+ if (focus) activeButton.focus();
+ content.scrollTop = 0;
+ };
+
+ navigation.addEventListener('click', (event) => {
+ const button = event.target.closest('[data-settings-page]');
+ if (button) activateSettingsPage(button.dataset.settingsPage);
+ });
+
+ navigation.addEventListener('keydown', (event) => {
+ const button = event.target.closest('[data-settings-page]');
+ if (!button || !['ArrowDown', 'ArrowUp', 'Home', 'End'].includes(event.key)) return;
+ const visibleButtons = [...navigation.querySelectorAll('.settings-nav-button')].filter((item) => !item.hidden);
+ const currentIndex = visibleButtons.indexOf(button);
+ let nextIndex = currentIndex;
+ if (event.key === 'ArrowDown') nextIndex = (currentIndex + 1) % visibleButtons.length;
+ if (event.key === 'ArrowUp') nextIndex = (currentIndex - 1 + visibleButtons.length) % visibleButtons.length;
+ if (event.key === 'Home') nextIndex = 0;
+ if (event.key === 'End') nextIndex = visibleButtons.length - 1;
+ event.preventDefault();
+ activateSettingsPage(visibleButtons[nextIndex].dataset.settingsPage, true);
+ });
+
+ const searchInput = layout.querySelector('#settingsSearchInput');
+ const searchEmpty = layout.querySelector('#settingsSearchEmpty');
+ searchInput.addEventListener('input', () => {
+ const query = searchInput.value.trim().toLocaleLowerCase('de-DE');
+ const visibleButtons = [];
+ navigation.querySelectorAll('.settings-nav-button').forEach((button) => {
+ const visible = !query || button.dataset.search.includes(query);
+ button.hidden = !visible;
+ if (visible) visibleButtons.push(button);
+ });
+ searchEmpty.hidden = visibleButtons.length > 0;
+ const activeButton = navigation.querySelector('.settings-nav-button.active');
+ if (visibleButtons.length === 0) {
+ Object.values(pages).forEach((page) => page.classList.remove('active'));
+ return;
+ }
+ if (!activeButton || activeButton.hidden || !content.querySelector('.settings-subpage.active')) {
+ activateSettingsPage((activeButton && !activeButton.hidden ? activeButton : visibleButtons[0]).dataset.settingsPage);
+ }
+ });
+
+ _renderLogPathsList(document.getElementById('logPathsList'));
+ const testWebhookBtn = document.getElementById('testWebhookBtn');
+ if (testWebhookBtn) {
+ testWebhookBtn.addEventListener('click', async () => {
+ const url = (document.getElementById('webhookUrlInput')?.value || '').trim();
+ const mention = (document.getElementById('webhookMentionInput')?.value || '').trim();
+ const hint = document.getElementById('webhookHint');
+ if (!url) { if (hint) hint.textContent = 'Keine URL eingetragen.'; return; }
+ testWebhookBtn.disabled = true;
+ const prev = testWebhookBtn.textContent;
+ testWebhookBtn.textContent = 'Sende…';
+ try {
+ const res = await window.api.testWebhook({ url, mention });
+ if (hint) hint.textContent = res && res.ok
+ ? `Test erfolgreich gesendet (HTTP ${res.status}).`
+ : `Test fehlgeschlagen: ${(res && (res.error || 'HTTP ' + res.status)) || 'unbekannt'}`;
+ } catch (err) {
+ if (hint) hint.textContent = `Test fehlgeschlagen: ${err.message || err}`;
+ } finally {
+ testWebhookBtn.disabled = false;
+ testWebhookBtn.textContent = prev;
+ }
+ });
+ }
+ const verboseInput = document.getElementById('logVerboseInput');
+ if (verboseInput) {
+ verboseInput.addEventListener('change', () => {
+ if (window.api && window.api.setLogVerbose) window.api.setLogVerbose(verboseInput.checked).catch(() => {});
+ });
+ }
+ const sbBtn = document.getElementById('createSupportBundleBtn');
+ if (sbBtn) {
+ sbBtn.addEventListener('click', async () => {
+ const hint = document.getElementById('supportBundleHint');
+ sbBtn.disabled = true;
+ const prevText = sbBtn.textContent;
+ sbBtn.textContent = 'Exportiere…';
+ try {
+ const res = await window.api.createSupportBundle();
+ if (res && res.ok) {
+ if (hint) hint.textContent = `Gespeichert: ${res.path} (${(res.bytes/1024).toFixed(1)} KB)`;
+ } else if (res && res.canceled) {
+ if (hint) hint.textContent = 'Abgebrochen.';
+ } else {
+ if (hint) hint.textContent = `Fehler: ${(res && res.error) || 'unbekannt'}`;
+ }
+ } catch (err) {
+ if (hint) hint.textContent = `Fehler: ${err.message || err}`;
+ } finally {
+ sbBtn.disabled = false;
+ sbBtn.textContent = prevText;
+ }
+ });
+ }
+
+ const updateFmBadge = () => {
+ const b = document.getElementById('folderMonitorStatusBadge');
+ if (!b) return;
+ const enabled = document.getElementById('fmEnabledInput')?.checked;
+ const hasPath = (document.getElementById('fmFolderPathInput')?.value || '').trim();
+ if (enabled && hasPath) { b.textContent = 'Aktiv'; b.className = 'panel-status active'; }
+ else { b.textContent = 'Inaktiv'; b.className = 'panel-status'; }
+ };
+ document.getElementById('fmEnabledInput')?.addEventListener('change', updateFmBadge);
+ document.getElementById('fmFolderPathInput')?.addEventListener('input', updateFmBadge);
+
+ document.getElementById('fmChooseFolderBtn')?.addEventListener('click', async () => {
+ const folder = await window.api.folderMonitorSelectFolder();
+ if (folder) {
+ document.getElementById('fmFolderPathInput').value = folder;
+ updateFmBadge();
+ scheduleSettingsSave();
+ }
+ });
+
+ document.getElementById('remoteCopyTokenBtn').addEventListener('click', async () => {
+ const token = document.getElementById('remoteTokenInput').value;
+ if (token) {
+ await window.api.copyToClipboard(token);
+ document.getElementById('remoteCopyTokenBtn').textContent = 'Kopiert!';
+ setTimeout(() => { document.getElementById('remoteCopyTokenBtn').textContent = 'Kopieren'; }, 1500);
+ }
+ });
+
+ document.getElementById('remoteRegenerateTokenBtn').addEventListener('click', async () => {
+ const newToken = await window.api.remoteGenerateToken();
+ document.getElementById('remoteTokenInput').value = newToken;
+ scheduleSettingsSave();
+ });
+
+ window.api.remoteStatus().then(status => {
+ const el = document.getElementById('remoteConnectionStatus');
+ if (!el) return;
+ if (status.running) {
+ el.textContent = `Aktiv auf Port ${status.port} — ${status.clientCount} Client(s) verbunden`;
+ el.style.color = '#10b981';
+ } else {
+ el.textContent = 'Nicht aktiv';
+ el.style.color = '#94a3b8';
+ }
+ }).catch(() => {});
+
+ (function wireDiagnostics() {
+ const enabledEl = document.getElementById('diagEnabledInput');
+ const portEl = document.getElementById('diagPortInput');
+ const modeEl = document.getElementById('diagBindModeInput');
+ const publicHostEl = document.getElementById('diagPublicHostInput');
+ const allowlistEl = document.getElementById('diagAllowlistInput');
+ const allowlistRow = document.getElementById('diagAllowlistRow');
+ const suggestRow = document.getElementById('diagSuggestRow');
+ const suggestChips = document.getElementById('diagSuggestChips');
+ const bindHintEl = document.getElementById('diagBindHint');
+ const codeEl = document.getElementById('diagCodeInput');
+ const issuedEl = document.getElementById('diagCodeIssued');
+ const badgeEl = document.getElementById('diagStatusBadge');
+ if (!enabledEl) return;
+
+ const fmtIssued = (ts) => {
+ if (!ts) return '';
+ try { return 'Code erstellt: ' + new Date(ts).toLocaleString('de-DE'); } catch { return ''; }
+ };
+ const parseAllowlist = () => allowlistEl.value.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+ const renderModeUi = (suggestedHosts) => {
+ const network = modeEl.value === 'network';
+ allowlistRow.style.display = network ? '' : 'none';
+ bindHintEl.innerHTML = network
+ ? 'Bindet an 0.0.0.0. Nur IPs/CIDRs aus der Allowlist dürfen verbinden (Loopback immer) — zusätzlich zum Token. Über Tailscale: trage deinen Tailnet-Bereich ein (z.B. 100.64.0.0/10) und die Tailscale-IP/MagicDNS oben als Code-Adresse. Transport ist plaintext über den Tunnel — Tailscale/WireGuard verschlüsselt.'
+ : 'Bindet nur an 127.0.0.1. Fernzugriff nur über einen Tunnel (z.B. Tailscale/SSH) — die sicherste Variante.';
+ const hosts = Array.isArray(suggestedHosts) ? suggestedHosts : [];
+ if (hosts.length) {
+ suggestRow.style.display = '';
+ suggestChips.innerHTML = '';
+ for (const h of hosts) {
+ const b = document.createElement('button');
+ b.className = 'btn btn-xs btn-secondary';
+ b.textContent = h;
+ b.addEventListener('click', () => { publicHostEl.value = h; save(); });
+ suggestChips.appendChild(b);
+ }
+ } else {
+ suggestRow.style.display = 'none';
+ }
+ };
+ let lastSuggested = [];
+ const applySettings = (s) => {
+ if (!s) return;
+ enabledEl.checked = !!s.enabled;
+ portEl.value = s.port || 9110;
+ modeEl.value = s.bindMode === 'network' ? 'network' : 'local';
+ publicHostEl.value = s.publicHost || '';
+ allowlistEl.value = Array.isArray(s.allowlist) ? s.allowlist.join('\n') : '';
+ lastSuggested = Array.isArray(s.suggestedHosts) ? s.suggestedHosts : [];
+ codeEl.value = s.code || '';
+ issuedEl.textContent = fmtIssued(s.codeIssuedAt);
+ renderModeUi(lastSuggested);
+ if (badgeEl) {
+ badgeEl.textContent = s.enabled ? 'Aktiv' : 'Inaktiv';
+ badgeEl.className = 'panel-status' + (s.enabled ? ' active' : '');
+ }
+ };
+ const refreshStatus = () => {
+ window.api.diagnosticsStatus().then((st) => {
+ const el = document.getElementById('diagConnectionStatus');
+ if (!el || !st) return;
+ if (st.running) {
+ const last = st.lastAccess ? new Date(st.lastAccess).toLocaleString('de-DE') : '—';
+ const scope = st.bindMode === 'network' ? `Netzwerk (Allowlist: ${st.allowlistCount})` : 'nur lokal';
+ el.textContent = `Aktiv auf ${st.bindAddress}:${st.port} (${scope}) — ${st.clientCount} Client(s) — Letzter Zugriff: ${last}`;
+ el.style.color = '#10b981';
+ } else {
+ el.textContent = 'Nicht aktiv';
+ el.style.color = '#94a3b8';
+ }
+ }).catch(() => {});
+ };
+ const save = async () => {
+ const allowlist = parseAllowlist();
+ if (enabledEl.checked && modeEl.value === 'network' && allowlist.length === 0) {
+ if (bindHintEl) { bindHintEl.innerHTML = 'Netzwerkmodus braucht mindestens eine IP/CIDR in der Allowlist — sonst bleibt es fail-closed auf Loopback.'; }
+ return;
+ }
+ const diagnosticsSettings = {
+ enabled: enabledEl.checked,
+ port: parseInt(portEl.value, 10) || 9110,
+ bindMode: modeEl.value,
+ publicHost: publicHostEl.value.trim(),
+ allowlist
+ };
+ await saveDiagnosticsSettingsTracked(diagnosticsSettings);
+ applySettings(await window.api.diagnosticsGetSettings());
+ refreshStatus();
+ };
+
+ window.api.diagnosticsGetSettings().then(applySettings).catch(() => {});
+ refreshStatus();
+
+ enabledEl.addEventListener('change', save);
+ portEl.addEventListener('change', save);
+ modeEl.addEventListener('change', () => { renderModeUi(lastSuggested); save(); });
+ publicHostEl.addEventListener('change', save);
+ allowlistEl.addEventListener('change', save);
+ document.getElementById('diagCopyCodeBtn').addEventListener('click', async () => {
+ if (!codeEl.value) return;
+ await window.api.copyToClipboard(codeEl.value);
+ const b = document.getElementById('diagCopyCodeBtn');
+ b.textContent = 'Kopiert!';
+ setTimeout(() => { b.textContent = 'Kopieren'; }, 1500);
+ });
+ document.getElementById('diagRegenerateBtn').addEventListener('click', async () => {
+ const r = await runConfigWrite(() => window.api.diagnosticsRegenerate());
+ if (r && r.code) { codeEl.value = r.code; issuedEl.textContent = fmtIssued(r.codeIssuedAt); }
+ refreshStatus();
+ });
+ })();
+
+ document.getElementById('exportBackupBtn').addEventListener('click', () => doBackupExport());
+ document.getElementById('importBackupBtn').addEventListener('click', () => doBackupImport());
+ document.getElementById('createOnlineBackupBtn').addEventListener('click', () => doOnlineBackupCreate());
+ document.getElementById('copyOnlineBackupKeyBtn').addEventListener('click', async () => {
+ const key = document.getElementById('onlineBackupKeyOutput').value;
+ if (!key) return;
+ await window.api.copyToClipboard(key);
+ showCopyToast('Online-Schlüssel kopiert');
+ });
+ document.getElementById('onlineBackupKeyInput').addEventListener('input', (event) => {
+ const valid = /^MHU2-[A-Za-z0-9_-]{70}$/.test(event.target.value.trim());
+ document.getElementById('restoreOnlineBackupBtn').disabled = !valid;
+ if (event.target.value && !valid) setOnlineBackupStatus('Der Schlüssel muss exakt 75 Zeichen lang sein.', '');
+ else setOnlineBackupStatus('', '');
+ });
+ document.getElementById('restoreOnlineBackupBtn').addEventListener('click', () => doOnlineBackupRestore());
+
+ document.getElementById('chooseLogFilePathBtn')?.addEventListener('click', chooseLogFilePath);
+ document.getElementById('openLogFolderBtn')?.addEventListener('click', () => window.api.openLogFolder());
+ document.getElementById('manualUpdateCheckBtn')?.addEventListener('click', requestUpdateCheck);
+ _syncHeaderUpdateState();
+ container.querySelectorAll('.settings-autosave').forEach((input) => {
+ const eventName = input.type === 'checkbox' ? 'change' : 'input';
+ input.addEventListener(eventName, scheduleSettingsSave);
+ });
+}
+
+async function chooseLogFilePath() {
+ const folders = await window.api.selectFolder();
+ if (!folders || !folders[0]) return;
+ const normalized = folders[0].replace(/[\\\/]+$/, '');
+ document.getElementById('logFilePathInput').value = `${normalized}\\fileuploader.log`;
+ scheduleSettingsSave();
+}
+
+function scheduleSettingsSave() {
+ if (closePreparationState !== 'open') return;
+ const feedback = document.getElementById('saveFeedback');
+ if (feedback) feedback.textContent = 'Speichert...';
+ clearTimeout(settingsSaveTimer);
+ settingsSaveTimer = setTimeout(() => {
+ settingsSaveTimer = null;
+ saveSettings({ feedbackText: 'Automatisch gespeichert' }).catch((err) => {
+ if (feedback) feedback.textContent = `Speichern fehlgeschlagen: ${err.message}`;
+ });
+ }, 350);
+}
+
+function saveSettings(options = {}) {
+ return settingsSaveCoordinator.run(options);
+}
+
+async function performSaveSettings(options = {}) {
+ const { feedbackText = 'Gespeichert!' } = options;
+ const newHosterSettings = { ...(config.hosterSettings || {}) };
+ const cur = config.globalSettings || {};
+ const curFm = cur.folderMonitor || {};
+ const curRemote = cur.remote || {};
+ const elTxt = (id, fb) => { const el = document.getElementById(id); return el ? el.value : fb; };
+ const elChk = (id, fb) => { const el = document.getElementById(id); return el ? !!el.checked : fb; };
+ const elInt = (id, curVal, dflt, lo, hi) => {
+ const el = document.getElementById(id);
+ if (!el) return curVal;
+ const n = parseInt(el.value || String(dflt), 10) || dflt;
+ return Math.max(lo, Math.min(hi, n));
+ };
+
+ const globalSettings = {
+ ...cur,
+ logFilePath: elTxt('logFilePathInput', cur.logFilePath || '').trim(),
+ logMode: (() => {
+ const el = document.getElementById('logModeInput');
+ if (!el) return cur.logMode || 'single';
+ const v = el.value;
+ return (v === 'single' || v === 'daily' || v === 'session') ? v : 'single';
+ })(),
+ resumeQueueOnLaunch: elChk('resumeQueueOnLaunchInput', cur.resumeQueueOnLaunch !== false),
+ parallelUploadCount: elInt('parallelUploadCountInput', cur.parallelUploadCount ?? 0, 0, 0, 100),
+ scaleParallelUploads: elChk('scaleParallelUploadsInput', !!cur.scaleParallelUploads),
+ removeFromQueueOnDone: elChk('removeFromQueueOnDoneInput', !!cur.removeFromQueueOnDone),
+ showDropTarget: elChk('showDropTargetInput', !!cur.showDropTarget),
+ globalMaxSpeedKbs: (() => {
+ const el = document.getElementById('globalMaxSpeedMbsInput');
+ if (!el) return cur.globalMaxSpeedKbs ?? 0;
+ return Math.max(0, Math.round((parseFloat(el.value || '0') || 0) * 1024));
+ })(),
+ logVerbose: elChk('logVerboseInput', !!cur.logVerbose),
+ webhookUrl: elTxt('webhookUrlInput', cur.webhookUrl || '').trim(),
+ webhookMention: elTxt('webhookMentionInput', cur.webhookMention || '').trim(),
+ autoRetryRounds: elInt('autoRetryRoundsInput', cur.autoRetryRounds ?? 0, 0, 0, 5),
+ autoRetryDelayMin: elInt('autoRetryDelayMinInput', cur.autoRetryDelayMin ?? 5, 5, 1, 120),
+ folderMonitor: {
+ ...curFm,
+ enabled: elChk('fmEnabledInput', !!curFm.enabled),
+ folderPath: elTxt('fmFolderPathInput', curFm.folderPath || '').trim(),
+ recursive: elChk('fmRecursiveInput', !!curFm.recursive),
+ filterMode: (() => { const el = document.getElementById('fmFilterModeInput'); return el ? (el.value || 'include') : (curFm.filterMode || 'include'); })(),
+ extensions: elTxt('fmExtensionsInput', curFm.extensions || '').trim(),
+ skipDuplicates: elChk('fmSkipDuplicatesInput', curFm.skipDuplicates !== false),
+ delaySec: elInt('fmDelaySecInput', curFm.delaySec ?? 3, 3, 1, 300),
+ autoStart: elChk('fmAutoStartInput', curFm.autoStart !== false),
+ hosters: document.querySelector('.fm-hoster-checkbox')
+ ? Array.from(document.querySelectorAll('.fm-hoster-checkbox:checked')).map(el => el.dataset.fmHoster)
+ : (curFm.hosters || [])
+ },
+ remote: {
+ ...curRemote,
+ enabled: elChk('remoteEnabledInput', !!curRemote.enabled),
+ port: elInt('remotePortInput', curRemote.port || 9100, 9100, 1024, 65535),
+ token: elTxt('remoteTokenInput', curRemote.token || '').trim(),
+ allowInput: elChk('remoteAllowInputInput', curRemote.allowInput !== false)
+ }
+ };
+
+ // Always on top setting
+ const aotCheckbox = document.getElementById('alwaysOnTopInput');
+ if (aotCheckbox) {
+ const newAot = !!aotCheckbox.checked;
+ if (newAot !== alwaysOnTopState) {
+ alwaysOnTopState = newAot;
+ await setAlwaysOnTopTracked(newAot);
+ }
+ }
+
+ // Drop target window
+ const dtCheckbox = document.getElementById('showDropTargetInput');
+ if (dtCheckbox) {
+ if (dtCheckbox.checked) await window.api.showDropTarget();
+ else await window.api.hideDropTarget();
+ }
+
+ for (const name of HOSTERS) {
+ const hs = { ...(hosterSettings[name] || {}) };
+ document.querySelectorAll(`.hs-input[data-hoster="${name}"]`).forEach(input => {
+ const field = input.dataset.hs;
+ if (input.type === 'checkbox') hs[field] = input.checked;
+ else if (field === 'maxSpeedMbs') hs.maxSpeedKbs = Math.max(0, Math.round((parseFloat(input.value) || 0) * 1024));
+ else hs[field] = parseInt(input.value, 10) || 0;
+ });
+ newHosterSettings[name] = hs;
+ }
+
+ await Promise.all([
+ saveHosterSettingsTracked(newHosterSettings),
+ saveGlobalSettingsTracked(globalSettings)
+ ]);
+ config.hosterSettings = newHosterSettings;
+ config.globalSettings = globalSettings;
+ hosterSettings = newHosterSettings;
+ clearTimeout(settingsSaveTimer);
+ settingsSaveTimer = null;
+
+ // Start/stop folder monitor based on settings
+ const fmSettings = globalSettings.folderMonitor;
+ const badge = document.getElementById('folderMonitorStatusBadge');
+ if (fmSettings && fmSettings.enabled && fmSettings.folderPath) {
+ try {
+ await window.api.folderMonitorStart(fmSettings);
+ if (badge) { badge.textContent = 'Aktiv'; badge.className = 'panel-status active'; }
+ } catch {
+ if (badge) { badge.textContent = 'Fehler'; badge.className = 'panel-status'; }
+ }
+ } else {
+ await window.api.folderMonitorStop();
+ if (badge) { badge.textContent = 'Inaktiv'; badge.className = 'panel-status'; }
+ }
+
+ // Start/stop remote server based on settings
+ const remoteSettings = globalSettings.remote;
+ const remoteBadge = document.getElementById('remoteStatusBadge');
+ if (remoteSettings) {
+ try {
+ const remoteSaveResult = await saveRemoteSettingsTracked(remoteSettings);
+ if (remoteSaveResult && remoteSaveResult.settings) {
+ globalSettings.remote = { ...remoteSaveResult.settings };
+ config.globalSettings = { ...(config.globalSettings || {}), remote: { ...remoteSaveResult.settings } };
+ const tokenInput = document.getElementById('remoteTokenInput');
+ if (tokenInput) tokenInput.value = remoteSaveResult.settings.token || '';
+ }
+ if (remoteSaveResult && remoteSaveResult.runtimeError) throw new Error(remoteSaveResult.runtimeError);
+ if (remoteBadge) {
+ remoteBadge.textContent = remoteSettings.enabled ? 'Aktiv' : 'Inaktiv';
+ remoteBadge.className = `panel-status${remoteSettings.enabled ? ' active' : ''}`;
+ }
+ // Update status display
+ const status = await window.api.remoteStatus();
+ const statusEl = document.getElementById('remoteConnectionStatus');
+ if (statusEl) {
+ if (status.running) {
+ statusEl.textContent = `Aktiv auf Port ${status.port} — ${status.clientCount} Client(s) verbunden`;
+ statusEl.style.color = '#10b981';
+ } else {
+ statusEl.textContent = 'Nicht aktiv';
+ statusEl.style.color = '#94a3b8';
+ }
+ }
+ } catch {
+ if (remoteBadge) {
+ remoteBadge.textContent = 'Fehler';
+ remoteBadge.className = 'panel-status';
+ }
+ }
+ }
+
+ const feedback = document.getElementById('saveFeedback');
+ feedback.textContent = feedbackText;
+ setTimeout(() => {
+ if (feedback.textContent === feedbackText) {
+ feedback.textContent = 'Änderungen werden automatisch gespeichert.';
+ }
+ }, 1800);
+}
+
+// --- Accounts ---
+function getCredentialLabel(name, account) {
+ if (!account) return 'Keine Zugangsdaten';
+ if (account.authType === 'api') return `API: ${maskCredential(account.apiKey) || 'nicht gesetzt'}`;
+ if (account.authType === 'login') return `Login: ${account.username || 'nicht gesetzt'}`;
+ // Fallback
+ if (account.username && account.password) return `Login: ${account.username}`;
+ if (account.apiKey) return `API: ${maskCredential(account.apiKey)}`;
+ return 'Keine Zugangsdaten';
+}
+
+function _buildAccountCardHtml(name, account, idx) {
+ const isDisabled = account.enabled === false;
+ const st = accountStatuses[account.id] || { status: 'unchecked', message: '' };
+ const statusPresentation = window.AccountStatus.getAccountStatusPresentation(isDisabled ? 'disabled' : st.status);
+ const statusLabel = statusPresentation.label;
+ const statusClass = statusPresentation.statusClass;
+ const credLabel = getCredentialLabel(name, account);
+ const userLabel = account.label && String(account.label).trim();
+ // Subtitle: "Label: XYZ • API: ABC… • " — the user-set label is the
+ // disambiguator for accounts that otherwise look identical (e.g. two byse
+ // API-key accounts where you can't tell what's what from the masked key).
+ const subtitleText = (userLabel ? `Label: ${userLabel} • ` : '') + credLabel;
+ const toggleLabel = isDisabled ? 'Aktivieren' : 'Deaktivieren';
+ const priorityLabel = idx === 0 ? 'Primär' : `Fallback #${idx}`;
+
+ const isSessionPaused = _sessionFailedKeys.has(`${name}:${account.id}`);
+ const sessionPausedBadge = isSessionPaused
+ ? `Pausiert (Session) `
+ : '';
+ const otpAction = !isDisabled && statusPresentation.requiresOtp
+ ? `
+
+
+
`
+ : '';
+
+ return `
+
+
☰
+
+
${escapeHtml(getAccountDisplayName(name, account))} ${priorityLabel} ${sessionPausedBadge}
+
${escapeHtml(subtitleText)}${st.message && !isDisabled ? ` • ${escapeHtml(st.message)}` : ''}
+ ${otpAction}
+
+
+
+ ${statusLabel}
+
+
+
+
+
+
+
+
+
+
+
Noch keine Accounts
+
Füge deinen ersten Hoster-Account hinzu. Die Zugangsdaten werden vor dem Speichern geprüft.
+
+
+
${cardsHtml}
+ ${_buildHosterSettingsHtml(name)}
+
+
+
+
+
+
+
+
+
`;
+ }
+ // API key
+ return `
+
+
+
+
+
`;
+}
+
+function wireCredentialVisibilityButtons(container) {
+ container.querySelectorAll('.toggle-vis').forEach(btn => {
+ btn.addEventListener('click', () => {
+ const input = btn.previousElementSibling;
+ const visible = input.type === 'password';
+ const fieldName = input.id === 'accField_apiKey' ? 'API-Key' : 'Passwort';
+ input.type = visible ? 'text' : 'password';
+ btn.setAttribute('aria-pressed', String(visible));
+ btn.setAttribute('aria-label', `${fieldName} ${visible ? 'verbergen' : 'anzeigen'}`);
+ btn.title = `${fieldName} ${visible ? 'verbergen' : 'anzeigen'}`;
+ });
+ });
+}
+
+let _accountModalReturnFocus = null;
+
+function openAccountModal(editAccountId) {
+ _accountModalReturnFocus = document.activeElement instanceof HTMLElement ? document.activeElement : null;
+ editingAccountId = editAccountId || null;
+ _resetAccountModalState();
+ const modal = document.getElementById('accountModal');
+ const title = document.getElementById('accountModalTitle');
+ const subtitle = document.getElementById('accountModalSubtitle');
+ const hosterRow = document.getElementById('accountHosterRow');
+ const hosterSelect = document.getElementById('accountHosterSelect');
+ const credsContainer = document.getElementById('accountCredsFields');
+ const statusEl = document.getElementById('accountModalStatus');
+ const saveBtn = document.getElementById('saveAccountBtn');
+ const labelInput = document.getElementById('accField_label');
+
+ statusEl.textContent = '';
+ statusEl.className = 'account-modal-status';
+
+ if (editingAccountId) {
+ // Edit mode
+ const found = findAccountById(editingAccountId);
+ if (!found) return;
+ title.textContent = 'Account bearbeiten';
+ subtitle.textContent = `Zugangsdaten für ${getAccountDisplayName(found.name, found.account)} bearbeiten und prüfen.`;
+ hosterRow.style.display = 'none';
+ saveBtn.textContent = window.AccountSubmit.getAccountSubmitLabel({ isEdit: true });
+ if (labelInput) labelInput.value = found.account.label || '';
+ credsContainer.innerHTML = getCredsFieldsHtml(found.account.authType || 'login', found.account, found.name);
+ } else {
+ // Add mode — always show all options (multiple accounts per hoster allowed)
+ title.textContent = 'Account hinzufügen';
+ subtitle.textContent = 'Wähle einen Hoster und gib deine Zugangsdaten ein. Der Account wird vor dem Anlegen geprüft.';
+ hosterRow.style.display = 'flex';
+ saveBtn.textContent = window.AccountSubmit.getAccountSubmitLabel({ isEdit: false });
+ hosterSelect.innerHTML = HOSTER_ADD_OPTIONS.map(opt =>
+ ``
+ ).join('');
+ const firstOpt = HOSTER_ADD_OPTIONS[0];
+ if (labelInput) labelInput.value = '';
+ credsContainer.innerHTML = getCredsFieldsHtml(firstOpt.authType, {}, firstOpt.value);
+ }
+
+ wireCredentialVisibilityButtons(credsContainer);
+
+ _wireCredFieldInvalidation();
+
+ modal.style.display = 'flex';
+ requestAnimationFrame(() => {
+ const firstControl = editingAccountId
+ ? document.getElementById('accField_label')
+ : hosterSelect;
+ if (firstControl) firstControl.focus();
+ });
+}
+
+function closeAccountModal() {
+ document.getElementById('accountModal').style.display = 'none';
+ _hideOtpField();
+ editingAccountId = null;
+ _resetAccountModalState();
+ const returnFocus = _accountModalReturnFocus;
+ _accountModalReturnFocus = null;
+ const focusTarget = returnFocus && returnFocus.isConnected
+ ? returnFocus
+ : document.getElementById('addAccountBtn');
+ if (focusTarget) focusTarget.focus();
+}
+
+function openDeleteAccountModal(accountId) {
+ const found = findAccountById(accountId);
+ if (!found) return;
+ const modal = document.getElementById('deleteAccountModal');
+ const msg = document.getElementById('deleteAccountMessage');
+ msg.textContent = `Account "${getAccountDisplayName(found.name, found.account)}" wirklich löschen?`;
+ modal.dataset.accountId = accountId;
+ modal.style.display = 'flex';
+}
+
+function closeDeleteModal() {
+ document.getElementById('deleteAccountModal').style.display = 'none';
+}
+
+async function deleteAccount(accountId) {
+ const found = findAccountById(accountId);
+ if (!found) return;
+ // Remove account from the array
+ const accounts = config.hosters[found.name];
+ if (Array.isArray(accounts)) {
+ config.hosters[found.name] = accounts.filter(a => a.id !== accountId);
+ }
+ delete accountStatuses[accountId];
+ // saveConfig is async — close the modal immediately so the UI feels
+ // responsive instead of waiting for the atomic write + safeStorage encrypt.
+ // The in-memory config already reflects the delete; the IPC just persists it.
+ closeDeleteModal();
+ ensureAccountStatusEntries();
+ syncSelectedUploadHosters();
+ if (getAllAccountsFlat().length === 0) renderHealthCheckResults([]);
+ renderAccounts();
+ renderHosterSummary();
+ // Fire-and-forget the persist. The earlier `await getConfig()` round-trip
+ // was redundant (we already have the truth in memory) and was the main
+ // source of perceived lag on add/delete.
+ saveConfigTracked({ hosters: config.hosters }).catch((err) => {
+ if (window.api && window.api.debugLog) window.api.debugLog(`deleteAccount saveConfig failed: ${err && err.message ? err.message : err}`);
+ showCopyToast('Account-Löschung konnte nicht persistiert werden — bitte erneut versuchen.');
+ });
+}
+
+function readAccountCredsFromModal(authType) {
+ const label = (document.getElementById('accField_label')?.value || '').trim();
+ if (authType === 'login') {
+ const username = (document.getElementById('accField_username')?.value || '').trim();
+ const password = (document.getElementById('accField_password')?.value || '').trim();
+ return { enabled: !!(username && password), authType: 'login', username, password, label };
+ }
+ // API
+ const apiKey = (document.getElementById('accField_apiKey')?.value || '').trim();
+ return { enabled: !!apiKey, authType: 'api', apiKey, label };
+}
+
+const _accountSubmitter = window.AccountSubmit.createAccountSubmitter();
+let _accountModalCommitLocked = false;
+let _autoCloseTimer = null;
+let _accountModalSession = 0;
+
+function _resetAccountModalState() {
+ _accountModalSession++;
+ _accountModalCommitLocked = false;
+ if (_autoCloseTimer) { clearTimeout(_autoCloseTimer); _autoCloseTimer = null; }
+ _syncAccountSubmitButton();
+}
+
+function _credsSnapshotKey(authType, creds) {
+ if (authType === 'login') return `login:${creds.username || ''}:${creds.password || ''}`;
+ return `api:${creds.apiKey || ''}`;
+}
+
+function _defaultAccountSubmitButtonText(ctx) {
+ return window.AccountSubmit.getAccountSubmitLabel({ isEdit: !!(ctx && ctx.isEdit) });
+}
+
+function _syncAccountSubmitButton() {
+ const saveBtn = document.getElementById('saveAccountBtn');
+ if (!saveBtn) return;
+ saveBtn.textContent = _defaultAccountSubmitButtonText(_determineHosterContext());
+ saveBtn.disabled = _accountSubmitter.isBusy() || _accountModalCommitLocked;
+}
+
+function _invalidateAccountSubmit() {
+ _accountModalSession++;
+ const statusEl = document.getElementById('accountModalStatus');
+ if (statusEl) {
+ statusEl.textContent = '';
+ statusEl.className = 'account-modal-status';
+ }
+ const saveBtn = document.getElementById('saveAccountBtn');
+ if (saveBtn && !_accountSubmitter.isBusy() && !_accountModalCommitLocked) {
+ saveBtn.disabled = false;
+ saveBtn.textContent = _defaultAccountSubmitButtonText(_determineHosterContext());
+ }
+}
+
+function _wireCredFieldInvalidation() {
+ const ids = ['accField_username', 'accField_password', 'accField_apiKey'];
+ for (const id of ids) {
+ const el = document.getElementById(id);
+ if (!el || el.dataset.invalidateBound === '1') continue;
+ el.addEventListener('input', _invalidateAccountSubmit);
+ el.dataset.invalidateBound = '1';
+ }
+}
+
+function _determineHosterContext() {
+ if (editingAccountId) {
+ const found = findAccountById(editingAccountId);
+ if (!found) return null;
+ return { hosterName: found.name, authType: found.account.authType || 'login', accountId: editingAccountId, isEdit: true };
+ }
+ const selectValue = document.getElementById('accountHosterSelect')?.value;
+ if (!selectValue) return null;
+ const opt = HOSTER_ADD_OPTIONS.find(o => o.value === selectValue);
+ if (!opt) return null;
+ return { hosterName: opt.hoster, authType: opt.authType, accountId: null, isEdit: false };
+}
+
+function _isAccountSubmitCurrent(session, ctx, snapshotKey) {
+ if (session !== _accountModalSession) return false;
+ const currentCtx = _determineHosterContext();
+ if (!currentCtx) return false;
+ if (currentCtx.hosterName !== ctx.hosterName || currentCtx.authType !== ctx.authType) return false;
+ if (currentCtx.accountId !== ctx.accountId || currentCtx.isEdit !== ctx.isEdit) return false;
+ const currentCreds = readAccountCredsFromModal(currentCtx.authType);
+ return _credsSnapshotKey(currentCtx.authType, currentCreds) === snapshotKey;
+}
+
+async function saveAccount() {
+ if (_accountSubmitter.isBusy() || _accountModalCommitLocked) return;
+
+ const ctx = _determineHosterContext();
+ if (!ctx) return;
+ const creds = readAccountCredsFromModal(ctx.authType);
+ const statusEl = document.getElementById('accountModalStatus');
+ const saveBtn = document.getElementById('saveAccountBtn');
+ if (!creds.enabled) {
+ statusEl.textContent = 'Bitte Zugangsdaten eingeben.';
+ statusEl.className = 'account-modal-status error';
+ return;
+ }
+
+ const snapshotKey = _credsSnapshotKey(ctx.authType, creds);
+ const mySession = _accountModalSession;
+ const otpInput = document.getElementById('accField_otp');
+ const otp = otpInput ? otpInput.value.trim() : '';
+ const payload = {
+ hoster: ctx.hosterName,
+ authType: ctx.authType,
+ username: creds.username || '',
+ password: creds.password || '',
+ apiKey: creds.apiKey || '',
+ otp
+ };
+
+ const submission = _accountSubmitter.submit({
+ validate: () => window.api.validateCredentials(payload),
+ commit: () => _persistAccount(ctx, creds),
+ afterCommit: (persisted, validation) => _applyCommittedAccount(persisted, validation),
+ isCurrent: () => _isAccountSubmitCurrent(mySession, ctx, snapshotKey)
+ });
+ if (!submission) return;
+ saveBtn.disabled = true;
+ saveBtn.textContent = _defaultAccountSubmitButtonText(ctx);
+ statusEl.textContent = 'Prüfe Zugangsdaten…';
+ statusEl.className = 'account-modal-status checking';
+
+ let result;
+ try {
+ result = await submission;
+ } catch (error) {
+ result = { status: 'error', error };
+ }
+
+ const current = _isAccountSubmitCurrent(mySession, ctx, snapshotKey);
+ if (result.status === 'committed' && current) {
+ _accountModalCommitLocked = true;
+ const validation = result.validation || {};
+ statusEl.textContent = validation.status === 'warn'
+ ? validation.message || 'Account wurde mit Warnung geprüft und gespeichert.'
+ : validation.message || 'Account wurde erfolgreich geprüft und gespeichert.';
+ statusEl.className = 'account-modal-status ok';
+ _hideOtpField();
+ saveBtn.textContent = _defaultAccountSubmitButtonText(ctx);
+ saveBtn.disabled = true;
+ if (_autoCloseTimer) clearTimeout(_autoCloseTimer);
+ _autoCloseTimer = setTimeout(() => {
+ _autoCloseTimer = null;
+ closeAccountModal();
+ }, 600);
+ return;
+ }
+
+ _syncAccountSubmitButton();
+ if (!current) return;
+
+ if (result.status === 'otp_required') {
+ const validation = result.validation || {};
+ statusEl.textContent = validation.message || 'OTP wurde an deine E-Mail gesendet.';
+ statusEl.className = 'account-modal-status error';
+ _showOtpField();
+ saveBtn.textContent = _defaultAccountSubmitButtonText(ctx);
+ return;
+ }
+
+ const validation = result.validation || {};
+ const msg = result.status === 'error'
+ ? (result.error && result.error.message) || 'Prüfung oder Speichern fehlgeschlagen'
+ : validation.message || 'Login fehlgeschlagen';
+ statusEl.textContent = msg;
+ statusEl.className = 'account-modal-status error';
+}
+
+function _copyHosterTree(hosters) {
+ const candidate = {};
+ for (const [name, accounts] of Object.entries(hosters || {})) {
+ candidate[name] = Array.isArray(accounts) ? accounts.map(account => ({ ...account })) : accounts;
+ }
+ return candidate;
+}
+
+async function _persistAccount(ctx, creds) {
+ const candidateHosters = _copyHosterTree(config.hosters);
+ if (!Array.isArray(candidateHosters[ctx.hosterName])) candidateHosters[ctx.hosterName] = [];
+ let accountId = ctx.accountId;
+ if (ctx.isEdit) {
+ const idx = candidateHosters[ctx.hosterName].findIndex(account => account.id === accountId);
+ if (idx < 0) throw new Error('Account nicht mehr in der Config — wurde extern gelöscht. Modal schließen und neu anlegen.');
+ candidateHosters[ctx.hosterName][idx] = { ...candidateHosters[ctx.hosterName][idx], ...creds };
+ } else {
+ accountId = `${ctx.hosterName}-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+ candidateHosters[ctx.hosterName].push({ id: accountId, ...creds });
+ }
+ await saveConfigTracked({ hosters: candidateHosters });
+ return { accountId, candidateHosters, isEdit: ctx.isEdit };
+}
+
+function _applyCommittedAccount(persisted, validation) {
+ const { accountId, candidateHosters, isEdit } = persisted;
+ config.hosters = candidateHosters;
+ accountStatuses[accountId] = { status: validation.status, message: validation.message || '' };
+ ensureAccountStatusEntries();
+ syncSelectedUploadHosters();
+ if (isEdit) {
+ updateAccountCard(accountId);
+ } else {
+ renderAccounts();
+ }
+ renderHosterSummary();
+}
+
+function _showOtpField() {
+ if (document.getElementById('accField_otp')) return; // already visible
+ const container = document.getElementById('accountCredsFields');
+ const otpHtml = `
+
+
+
+
`;
+ container.insertAdjacentHTML('beforeend', otpHtml);
+ // Auto-focus the OTP field
+ setTimeout(() => document.getElementById('accField_otp')?.focus(), 50);
+}
+
+function _hideOtpField() {
+ const row = document.getElementById('otpFieldRow');
+ if (row) row.remove();
+}
+
+// --- History ---
+async function loadHistory() {
+ const history = await window.api.getHistory();
+ window._historyForStats = history || [];
+ _historyEverLoaded = true;
+ _historyDirty = false;
+ _invalidateHosterLifetimeCache();
+ const retSel = document.getElementById('historyRetentionSelect');
+ if (retSel) retSel.value = (config.globalSettings && config.globalSettings.historyRetention) || 'all';
+ const container = document.getElementById('historyContainer');
+
+ if (!history || history.length === 0) {
+ historyRowsData = [];
+ historySidebarCounts = { total: 0, success: 0, error: 0 };
+ updateHistorySidebarSummary();
+ container.innerHTML = 'Noch keine Uploads.
';
+ return;
+ }
+
+ historySortState = { key: 'date', direction: 'desc' };
+ historyRowsData = [];
+ historySidebarCounts = { total: 0, success: 0, error: 0 };
+ let order = 0;
+
+ for (const batch of history) {
+ const dt = formatDateTime(batch.timestamp || new Date());
+ for (const file of (batch.files || [])) {
+ for (const result of (file.results || [])) {
+ historySidebarCounts.total++;
+ const isError = result.status === 'aborted' || result.status === 'error';
+ if (isError) historySidebarCounts.error++;
+ else historySidebarCounts.success++;
+ const detail = isError
+ ? String(result.error || result.message || (result.status === 'aborted' ? 'Abgebrochen' : 'Fehlgeschlagen'))
+ : (result.download_url || result.embed_url || '');
+ historyRowsData.push({
+ date: dt.text, dateTs: dt.ts,
+ filename: file.name || '', host: result.hoster || '',
+ link: detail,
+ isError, order: order++
+ });
+ }
+ }
+ }
+
+ updateHistorySidebarSummary();
+ renderHistoryTable(container);
+}
+
+async function exportHistory() {
+ const history = await window.api.getHistory();
+ if (!history || history.length === 0) {
+ alert('Kein Verlauf zum Exportieren vorhanden.');
+ return;
+ }
+
+ const asCsv = confirm('Verlauf als CSV exportieren?\n\nOK = CSV\nAbbrechen = JSON');
+ const format = asCsv ? 'csv' : 'json';
+ const result = await window.api.exportHistory(format);
+
+ if (!result || result.canceled) return;
+ if (!result.ok) {
+ alert(result.error || 'Export fehlgeschlagen.');
+ return;
+ }
+
+ showCopyToast(`Verlauf exportiert (${result.totalRows || 0} Zeilen)`);
+}
+
+// Memoize sort result: invalidated only when data length changes or sort state changes.
+// Selection changes and re-renders reuse the cached sorted array — a big win when
+// the panel has thousands of rows and the sort is stable.
+let _recentSortCache = { sig: '', result: [] };
+
+function sortRecentFiles(data) {
+ const { key, direction } = recentSortState;
+ const sig = `${key}|${direction}|${data.length}|${_recentDataVersion}`;
+ if (_recentSortCache.sig === sig) return _recentSortCache.result;
+
+ const sorted = data.slice();
+ const dir = direction === 'asc' ? 1 : -1;
+ sorted.sort((a, b) => {
+ if (key === 'date') return dir * ((a.dateTs - b.dateTs) || (a.order - b.order));
+ if (key === 'filename') return dir * _collatorDE.compare(a.filename, b.filename);
+ if (key === 'host') return dir * _collatorDE.compare(a.host, b.host);
+ if (key === 'link') return dir * _collatorDE.compare(a.link, b.link);
+ return 0;
+ });
+ _recentSortCache = { sig, result: sorted };
+ return sorted;
+}
+
+function updateRecentSortHeaders() {
+ const head = document.getElementById('recentFilesHead');
+ if (!head) return;
+ head.querySelectorAll('th[data-recent-sort]').forEach(th => {
+ const key = th.dataset.recentSort;
+ const active = recentSortState.key === key;
+ const arrow = active ? (recentSortState.direction === 'asc' ? '▲' : '▼') : '↕';
+ th.classList.toggle('active', active);
+ const indicator = th.querySelector('.sort-indicator');
+ if (indicator) indicator.textContent = arrow;
+ });
+}
+
+let _recentListenersBound = false;
+
+function _buildRecentRowHtml(row) {
+ const cls = `recent-file-row${row.isError ? ' error' : ''}${selectedRecentIds.has(row.order) ? ' selected' : ''}`;
+ return ``
+ + `| ${escapeHtml(row.date)} | `
+ + `${escapeHtml(row.filename)} | `
+ + `${escapeHtml(row.host)} | `
+ + `${escapeHtml(row.link)} | `
+ + `
`;
+}
+
+// Tracks the last rendered dataset so we can append-only when the user is just
+// accumulating new uploads (the default case: sort=date desc, rows only grow).
+let _recentLastRenderedSig = '';
+let _recentLastRenderedLen = 0;
+let _recentPendingAppends = 0;
+let _recentWorking = [];
+let _recentLastRange = { start: -1, end: -1 };
+let _recentScrollQueued = false;
+
+function _onRecentScroll() {
+ if (_recentScrollQueued) return;
+ _recentScrollQueued = true;
+ requestAnimationFrame(() => { _recentScrollQueued = false; _renderRecentVirtualRows(); });
+}
+
+function _renderRecentVirtualRows() {
+ const wrap = document.querySelector('.recent-files-table-wrap');
+ const tbody = document.getElementById('recentFilesBody');
+ if (!wrap || !tbody) return;
+ const total = _recentWorking.length;
+ if (!total) return;
+ const scrollTop = wrap.scrollTop;
+ const viewportHeight = Math.max(wrap.clientHeight, 400);
+ const startIdx = Math.max(0, Math.floor(scrollTop / VIRTUAL_ROW_HEIGHT) - VIRTUAL_OVERSCAN);
+ const endIdx = Math.min(total, Math.ceil((scrollTop + viewportHeight) / VIRTUAL_ROW_HEIGHT) + VIRTUAL_OVERSCAN);
+ if (startIdx === _recentLastRange.start && endIdx === _recentLastRange.end) return;
+ _recentLastRange = { start: startIdx, end: endIdx };
+ const topPad = startIdx * VIRTUAL_ROW_HEIGHT;
+ const bottomPad = Math.max(0, (total - endIdx) * VIRTUAL_ROW_HEIGHT);
+ const parts = [];
+ if (topPad > 0) parts.push(` |
`);
+ for (let i = startIdx; i < endIdx; i++) parts.push(_buildRecentRowHtml(_recentWorking[i]));
+ if (bottomPad > 0) parts.push(` |
`);
+ tbody.innerHTML = parts.join('');
+}
+
+function renderRecentUploadsPanel(appendOnly = false) {
+ const tbody = document.getElementById('recentFilesBody');
+ if (!tbody) return;
+ _recentPendingAppends = 0;
+ const wrap = tbody.closest('.recent-files-table-wrap');
+
+ if (!sessionFilesData.length) {
+ tbody.innerHTML = '| Noch keine Uploads in dieser Session. |
';
+ _recentWorking = [];
+ _recentLastRange = { start: -1, end: -1 };
+ } else {
+ const prevLen = _recentWorking.length;
+ _recentWorking = sortRecentFiles(sessionFilesData);
+ _recentLastRange = { start: -1, end: -1 };
+ const sig = `${recentSortState.key}|${recentSortState.direction}`;
+ if (wrap) {
+ const added = _recentWorking.length - prevLen;
+ if (sig === 'date|desc' && wrap.scrollTop <= 48) wrap.scrollTop = 0;
+ else if (sig === 'date|desc' && added > 0) wrap.scrollTop += added * VIRTUAL_ROW_HEIGHT;
+ }
+ _renderRecentVirtualRows();
+ }
+
+ // Event delegation – bind once, not per-row
+ if (!_recentListenersBound) {
+ _recentListenersBound = true;
+ if (wrap) {
+ wrap.addEventListener('scroll', _onRecentScroll, { passive: true });
+ if (typeof window.ResizeObserver !== 'undefined') new window.ResizeObserver(_onRecentScroll).observe(wrap);
+ }
+ tbody.addEventListener('click', (e) => {
+ const tr = e.target.closest('.recent-file-row');
+ if (!tr) return;
+ // Clear queue selection when clicking in recent panel — class-toggle only.
+ if (selectedJobIds.size > 0) { selectedJobIds.clear(); applyQueueSelectionClasses(); updateQueueActionButtons(); }
+ const id = parseInt(tr.dataset.order, 10);
+ if (e.ctrlKey || e.metaKey) {
+ if (selectedRecentIds.has(id)) selectedRecentIds.delete(id);
+ else selectedRecentIds.add(id);
+ } else if (e.shiftKey && selectedRecentIds.size > 0) {
+ // Reuse the already-sorted array from the sort cache instead of
+ // querying every .recent-file-row in the DOM (O(visible) vs O(N)
+ // on large panels).
+ const sortedOrders = (_recentSortCache.result || sortRecentFiles(sessionFilesData))
+ .map(r => r.order);
+ const lastIdx = sortedOrders.findIndex(o => selectedRecentIds.has(o));
+ const curIdx = sortedOrders.indexOf(id);
+ if (lastIdx >= 0 && curIdx >= 0) {
+ const from = Math.min(lastIdx, curIdx);
+ const to = Math.max(lastIdx, curIdx);
+ for (let i = from; i <= to; i++) selectedRecentIds.add(sortedOrders[i]);
+ }
+ } else {
+ selectedRecentIds.clear();
+ selectedRecentIds.add(id);
+ }
+ // Selection change — toggle classes, no tbody rebuild.
+ applyRecentSelectionClasses();
+ });
+
+ tbody.addEventListener('dblclick', (e) => {
+ const tr = e.target.closest('.recent-file-row');
+ if (!tr || tr.classList.contains('error')) return;
+ const link = tr.dataset.link;
+ if (link) { window.api.copyToClipboard(link); showCopyToast('Link kopiert'); }
+ });
+ }
+
+ updateRecentSortHeaders();
+}
+
+const HISTORY_RENDER_CAP = 2000;
+let _historyWorking = [];
+let _historyLastRange = { start: -1, end: -1 };
+let _historyListenersBound = false;
+let _historyScrollQueued = false;
+
+function _onHistoryScroll() {
+ if (_historyScrollQueued) return;
+ _historyScrollQueued = true;
+ requestAnimationFrame(() => { _historyScrollQueued = false; _renderHistoryVirtualRows(); });
+}
+
+function _renderHistoryVirtualRows() {
+ const container = document.getElementById('historyContainer');
+ const tbody = document.getElementById('historyBody');
+ if (!container || !tbody) return;
+ const total = _historyWorking.length;
+ const scrollTop = container.scrollTop;
+ const viewportHeight = Math.max(container.clientHeight, 600);
+ const startIdx = Math.max(0, Math.floor(scrollTop / VIRTUAL_ROW_HEIGHT) - VIRTUAL_OVERSCAN);
+ const endIdx = Math.min(total, Math.ceil((scrollTop + viewportHeight) / VIRTUAL_ROW_HEIGHT) + VIRTUAL_OVERSCAN);
+ if (startIdx === _historyLastRange.start && endIdx === _historyLastRange.end) return;
+ _historyLastRange = { start: startIdx, end: endIdx };
+ const topPad = startIdx * VIRTUAL_ROW_HEIGHT;
+ const bottomPad = Math.max(0, (total - endIdx) * VIRTUAL_ROW_HEIGHT);
+ const parts = [];
+ if (topPad > 0) parts.push(` |
`);
+ for (let i = startIdx; i < endIdx; i++) {
+ const row = _historyWorking[i];
+ const link = row.link || '';
+ parts.push('| `);
+ parts.push(escapeHtml(row.date));
+ parts.push(' | ');
+ parts.push(escapeHtml(row.filename));
+ parts.push(' | ');
+ parts.push(escapeHtml(row.host));
+ parts.push(' | ');
+ parts.push(escapeHtml(link));
+ parts.push(' |
');
+ }
+ if (bottomPad > 0) parts.push(` |
`);
+ tbody.innerHTML = parts.join('');
+}
+
+function _getVisibleHistoryRows() {
+ if (historySidebarFilter === 'success') return historyRowsData.filter(row => !row.isError);
+ if (historySidebarFilter === 'error') return historyRowsData.filter(row => row.isError);
+ return historyRowsData;
+}
+
+function renderHistoryTable(container) {
+ const visibleRows = _getVisibleHistoryRows();
+ if (!container || !visibleRows.length) {
+ if (container) container.innerHTML = 'Noch keine Uploads.
';
+ const emptyNotice = document.getElementById('historyCapNotice');
+ if (emptyNotice) emptyNotice.style.display = 'none';
+ _historyWorking = [];
+ return;
+ }
+
+ const total = visibleRows.length;
+ const working = total > HISTORY_RENDER_CAP ? visibleRows.slice(-HISTORY_RENDER_CAP) : visibleRows;
+ const notice = document.getElementById('historyCapNotice');
+ if (notice) {
+ if (total > HISTORY_RENDER_CAP) {
+ notice.style.display = '';
+ notice.textContent = `Zeige neueste ${HISTORY_RENDER_CAP.toLocaleString('de-DE')} von ${total.toLocaleString('de-DE')} Einträgen. Der vollständige Verlauf bleibt gespeichert und ist über „Verlauf exportieren“ verfügbar.`;
+ } else {
+ notice.style.display = 'none';
+ }
+ }
+
+ _historyWorking = sortHistoryRows(working);
+ _historyLastRange = { start: -1, end: -1 };
+ const headerCell = (key, label) => {
+ const active = historySortState.key === key;
+ const dir = active ? (historySortState.direction === 'asc' ? '▲' : '▼') : '↕';
+ return `${label}${dir} | `;
+ };
+
+ container.innerHTML = `
+ ${headerCell('date', 'Datum')}${headerCell('filename', 'Dateiname')}${headerCell('host', 'Hoster')}${headerCell('link', 'Link')}
+
`;
+
+ if (!_historyListenersBound) {
+ _historyListenersBound = true;
+ container.addEventListener('scroll', _onHistoryScroll, { passive: true });
+ if (typeof window.ResizeObserver !== 'undefined') new window.ResizeObserver(_onHistoryScroll).observe(container);
+ container.addEventListener('click', (e) => {
+ const th = e.target.closest('th.sortable');
+ if (th && container.contains(th)) {
+ const key = th.dataset.historySort;
+ const defaultDir = key === 'date' ? 'desc' : 'asc';
+ if (!_historySortClicked || historySortState.key !== key) {
+ _historySortClicked = true;
+ historySortState.key = key;
+ historySortState.direction = defaultDir;
+ } else {
+ historySortState.direction = historySortState.direction === 'asc' ? 'desc' : 'asc';
+ }
+ container.scrollTop = 0;
+ renderHistoryTable(container);
+ return;
+ }
+ const row = e.target.closest('.history-row');
+ if (row && !row.classList.contains('error')) {
+ const link = row.dataset.link;
+ if (link) { window.api.copyToClipboard(link); showCopyToast('Link kopiert'); }
+ }
+ });
+ }
+
+ _renderHistoryVirtualRows();
+}
+
+function sortHistoryRows(rows) {
+ const { key, direction } = historySortState;
+ const factor = direction === 'asc' ? 1 : -1;
+ return rows.slice().sort((a, b) => {
+ const cmp = key === 'date' ? a.dateTs - b.dateTs : _collatorDE.compare(String(a[key] || ''), String(b[key] || ''));
+ return (cmp || a.order - b.order) * factor;
+ });
+}
+
+let closePreparationPromise = null;
+let closePreparationInertState = [];
+let closePreparationOverlayState = null;
+let closePreparationGeneration = 0;
+let activeClosePreparationAttempt = null;
+const CLOSE_PREPARATION_TIMEOUT_MS = 1200;
+
+function waitForClosePreparationStep(promise) {
+ return Promise.race([
+ Promise.resolve(promise),
+ new Promise((_, reject) => setTimeout(() => reject(new Error('Speichern vor dem Beenden hat zu lange gedauert')), CLOSE_PREPARATION_TIMEOUT_MS))
+ ]);
+}
+
+function setClosePreparationUi(active) {
+ const overlay = document.getElementById('shutdownOverlay');
+ const message = document.getElementById('shutdownMessage');
+ const cancelButton = document.getElementById('cancelShutdownBtn');
+ if (!overlay || !message || !cancelButton) return;
+ if (active) {
+ if (closePreparationOverlayState) return;
+ closePreparationOverlayState = {
+ display: overlay.style.display,
+ message: message.innerHTML,
+ cancelDisplay: cancelButton.style.display
+ };
+ closePreparationInertState = Array.from(document.body.children)
+ .filter(element => element !== overlay && 'inert' in element)
+ .map(element => ({ element, inert: element.inert }));
+ closePreparationInertState.forEach(({ element }) => { element.inert = true; });
+ message.textContent = 'Einstellungen werden gespeichert…';
+ cancelButton.style.display = 'none';
+ overlay.style.display = 'flex';
+ return;
+ }
+ closePreparationInertState.forEach(({ element, inert }) => {
+ if (element.isConnected) element.inert = inert;
+ });
+ closePreparationInertState = [];
+ overlay.style.display = closePreparationOverlayState ? closePreparationOverlayState.display : 'none';
+ message.innerHTML = closePreparationOverlayState ? closePreparationOverlayState.message : '';
+ cancelButton.style.display = closePreparationOverlayState ? closePreparationOverlayState.cancelDisplay : '';
+ closePreparationOverlayState = null;
+}
+
+function isCurrentClosePreparation(generation, attempt) {
+ return generation === closePreparationGeneration && attempt === activeClosePreparationAttempt;
+}
+
+async function recoverWindowClose(generation, attempt, originalError) {
+ if (!isCurrentClosePreparation(generation, attempt)) return;
+ closePreparationState = 'recovering';
+ let restored = false;
+ try {
+ restored = await waitForClosePreparationStep(window.api.finishClosePreparation({ ready: false, attempt }));
+ } catch (error) {
+ if (isCurrentClosePreparation(generation, attempt)) showCopyToast(error.message || String(error), 8000);
+ return;
+ }
+ if (!isCurrentClosePreparation(generation, attempt)) return;
+ if (restored !== true) {
+ showCopyToast('Die Anwendung konnte nach dem fehlgeschlagenen Speichern nicht entsperrt werden', 8000);
+ return;
+ }
+ try {
+ await waitForClosePreparationStep(withCloseWriteAccess(async () => {
+ await flushConfigWrites();
+ if (!isCurrentClosePreparation(generation, attempt)) return;
+ await persistQueueStateNow();
+ await flushConfigWrites();
+ if (failedConfigWriteOperations.length !== 0) throw new Error('Nicht alle Einstellungen konnten gespeichert werden');
+ }));
+ } catch (error) {
+ if (isCurrentClosePreparation(generation, attempt)) showCopyToast(error.message || String(error), 8000);
+ return;
+ }
+ if (!isCurrentClosePreparation(generation, attempt)) return;
+ closePreparationPromise = null;
+ activeClosePreparationAttempt = null;
+ closePreparationState = 'open';
+ setClosePreparationUi(false);
+ showCopyToast(originalError.message || String(originalError), 8000);
+}
+
+function prepareForWindowClose(attempt) {
+ if (!Number.isInteger(attempt)) return Promise.resolve(false);
+ if (closePreparationPromise && activeClosePreparationAttempt === attempt) return closePreparationPromise;
+ const generation = ++closePreparationGeneration;
+ activeClosePreparationAttempt = attempt;
+ closePreparationState = 'preparing';
+ setClosePreparationUi(true);
+ closePreparationPromise = (async () => {
+ if (_doneRemovalCoalescer) _doneRemovalCoalescer.drainSync();
+ await waitForClosePreparationStep(withCloseWriteAccess(flushPendingSettingsSaves));
+ if (!isCurrentClosePreparation(generation, attempt)) return;
+ const pendingQueue = buildPersistedQueueState();
+ closePreparationState = 'sealed';
+ await waitForClosePreparationStep(flushConfigWrites());
+ if (!isCurrentClosePreparation(generation, attempt)) return;
+ const accepted = await waitForClosePreparationStep(window.api.finishClosePreparation({ ready: true, attempt, pendingQueue }));
+ if (!accepted) throw new Error('Einstellungen konnten vor dem Beenden nicht gespeichert werden');
+ })();
+ closePreparationPromise.catch(error => recoverWindowClose(generation, attempt, error));
+ return closePreparationPromise;
+}
+
+// --- Setup Listeners ---
+function setupListeners() {
+ try { initMenuBar(); } catch (err) { console.error('menu bar init failed', err); }
+ document.querySelectorAll('[data-upload-sidebar-target]').forEach(button => {
+ button.addEventListener('click', () => setUploadSidebarFilter(button.dataset.uploadSidebarTarget));
+ });
+ document.querySelectorAll('[data-accounts-sidebar-filter]').forEach(button => {
+ button.addEventListener('click', () => setAccountSidebarFilter(button.dataset.accountsSidebarFilter));
+ });
+ document.querySelectorAll('[data-history-filter]').forEach(button => {
+ button.addEventListener('click', () => setHistorySidebarFilter(button.dataset.historyFilter));
+ });
+ _syncSidebarFilterButtons('[data-upload-sidebar-target]', 'uploadSidebarTarget', uploadSidebarFilter);
+ _syncSidebarFilterButtons('[data-accounts-sidebar-filter]', 'accountsSidebarFilter', accountSidebarFilter);
+ _syncSidebarFilterButtons('[data-history-filter]', 'historyFilter', historySidebarFilter);
+ document.getElementById('addFilesBtn').addEventListener('click', pickFiles);
+ document.getElementById('addFolderBtn').addEventListener('click', pickFolder);
+ document.getElementById('startUploadBtn').addEventListener('click', startUpload);
+ document.getElementById('startSelectedBtn').addEventListener('click', startSelectedUpload);
+
+ // Recent files sort headers
+ document.getElementById('recentFilesHead').addEventListener('click', (e) => {
+ const th = e.target.closest('th[data-recent-sort]');
+ if (!th) return;
+ const key = th.dataset.recentSort;
+ if (recentSortState.key === key) {
+ recentSortState.direction = recentSortState.direction === 'desc' ? 'asc' : 'desc';
+ } else {
+ recentSortState.key = key;
+ recentSortState.direction = key === 'date' ? 'desc' : 'asc';
+ }
+ _recentLastRenderedSig = '';
+ renderRecentUploadsPanel();
+ });
+
+ // Recent files context menu
+ document.getElementById('recentFilesBody').addEventListener('contextmenu', (e) => {
+ const tr = e.target.closest('.recent-file-row');
+ if (!tr) return;
+ e.preventDefault();
+ e.stopPropagation();
+ const id = parseInt(tr.dataset.order, 10);
+ if (!selectedRecentIds.has(id)) {
+ selectedRecentIds.clear();
+ selectedRecentIds.add(id);
+ renderRecentUploadsPanel();
+ }
+ const menu = document.getElementById('recentContextMenu');
+ menu.style.display = 'block';
+ menu.style.left = Math.min(e.clientX, window.innerWidth - 180) + 'px';
+ menu.style.top = Math.min(e.clientY, window.innerHeight - 80) + 'px';
+ });
+
+ document.getElementById('recentContextMenu').addEventListener('click', (e) => {
+ const item = e.target.closest('.ctx-item');
+ if (!item) return;
+ hideContextMenu();
+ const action = item.dataset.action;
+ if (action === 'recent-copy-links') copySelectedRecentLinks();
+ else if (action === 'recent-delete') deleteSelectedRecentFiles();
+ });
+ document.getElementById('reuploadSelectedBtn').addEventListener('click', retrySelectedJobs);
+ document.getElementById('abortSelectedBtn').addEventListener('click', abortSelectedJobs);
+ document.getElementById('finishStopBtn').addEventListener('click', finishUploadsInProgress);
+ document.getElementById('abortAllBtn').addEventListener('click', abortAllUploads);
+ document.getElementById('moveTopBtn').addEventListener('click', () => moveSelectedJobs('top'));
+ document.getElementById('moveUpBtn').addEventListener('click', () => moveSelectedJobs('up'));
+ document.getElementById('moveDownBtn').addEventListener('click', () => moveSelectedJobs('down'));
+ document.getElementById('moveBottomBtn').addEventListener('click', () => moveSelectedJobs('bottom'));
+ document.getElementById('accountsRunHealthCheckBtn').addEventListener('click', () => runHealthCheck('manual'));
+ document.getElementById('toggleAllAccountsBtn').addEventListener('click', () => _setAllAccountGroupsOpen(!_allAccountGroupsOpen()));
+ document.getElementById('copyAllLinksBtn').addEventListener('click', copyAllLinks);
+ document.getElementById('clearRecentFilesBtn').addEventListener('click', clearAllRecentFiles);
+ document.getElementById('exportRecentFilesBtn').addEventListener('click', exportAllRecentFiles);
+ document.getElementById('retryFailedBtn').addEventListener('click', () => {
+ queueJobs.forEach(j => { if (j.status === 'error') selectedJobIds.add(j.id); });
+ retrySelectedJobs();
+ });
+ document.getElementById('importLogBtn').addEventListener('click', importUploadLog);
+ document.getElementById('confirmHosterModalBtn').addEventListener('click', applyHosterSelection);
+ document.getElementById('cancelHosterModalBtn').addEventListener('click', cancelHosterModal);
+ document.getElementById('closeHosterModalBtn').addEventListener('click', cancelHosterModal);
+ document.getElementById('selectAllHostersBtn').addEventListener('click', () => {
+ document.querySelectorAll('input[data-hoster-modal]').forEach(input => {
+ input.checked = true;
+ input.closest('.hoster-option')?.classList.add('selected');
+ });
+ });
+ document.getElementById('clearHostersBtn').addEventListener('click', () => {
+ document.querySelectorAll('input[data-hoster-modal]').forEach(input => {
+ input.checked = false;
+ input.closest('.hoster-option')?.classList.remove('selected');
+ });
+ });
+ document.getElementById('saveSettingsBtn').addEventListener('click', saveSettings);
+
+ document.getElementById('clearHistoryBtn').addEventListener('click', async () => {
+ if (!confirm('Verlauf wirklich löschen?')) return;
+ try {
+ await runConfigWrite(() => window.api.clearHistory());
+ loadHistory();
+ } catch (error) {
+ showCopyToast(error.message || String(error));
+ }
+ });
+ document.getElementById('exportHistoryBtn').addEventListener('click', exportHistory);
+
+ const historyRetentionSelect = document.getElementById('historyRetentionSelect');
+ if (historyRetentionSelect) {
+ historyRetentionSelect.addEventListener('change', async () => {
+ const value = historyRetentionSelect.value;
+ const prev = (config.globalSettings && config.globalSettings.historyRetention) || 'all';
+ if (value !== 'all') {
+ const preview = await window.api.pruneHistory(value, { dryRun: true });
+ if (preview && preview.removedRows > 0) {
+ const ok = confirm(`${preview.removedRows.toLocaleString('de-DE')} Verlaufseinträge werden dauerhaft entfernt.\n\nFortfahren?`);
+ if (!ok) { historyRetentionSelect.value = prev; return; }
+ }
+ }
+ try {
+ const res = await runConfigWrite(() => window.api.pruneHistory(value));
+ config.globalSettings = { ...(config.globalSettings || {}), historyRetention: value };
+ if (res && res.removedRows > 0) showCopyToast(`Verlauf gekürzt: ${res.removedRows.toLocaleString('de-DE')} entfernt`);
+ loadHistory();
+ } catch (error) {
+ historyRetentionSelect.value = prev;
+ showCopyToast(error.message || String(error));
+ }
+ });
+ }
+
+ // Auto health check toggle
+ const autoToggle = document.getElementById('autoHealthCheckToggle');
+ if (autoToggle) {
+ autoToggle.checked = autoHealthCheckEnabled;
+ autoToggle.addEventListener('change', (e) => {
+ autoHealthCheckEnabled = !!e.target.checked;
+ try { localStorage.setItem(AUTO_CHECK_PREF_KEY, autoHealthCheckEnabled ? '1' : '0'); } catch {}
+ });
+ }
+
+ // Virtual scroll for large queues
+ const queueContainer = document.getElementById('queueContainer');
+ if (queueContainer) queueContainer.addEventListener('scroll', _onQueueScroll, { passive: true });
+ if (queueContainer && typeof window.ResizeObserver !== 'undefined') {
+ new window.ResizeObserver(_onQueueScroll).observe(queueContainer);
+ }
+
+ // Queue table sorting
+ document.querySelectorAll('#queueTable th.sortable').forEach(th => {
+ th.addEventListener('click', (e) => {
+ // Don't sort if click was on the resizer handle
+ if (e.target.classList.contains('col-resizer')) return;
+ const key = th.dataset.sort;
+ if (queueSortState.key === key) queueSortState.direction = queueSortState.direction === 'asc' ? 'desc' : 'asc';
+ else { queueSortState.key = key; queueSortState.direction = 'asc'; }
+ _lastVisibleRange = { start: -1, end: -1 }; // force full rebuild after re-sort
+ renderQueueTable();
+ });
+ });
+
+ // Queue table column resizing (JDownloader-style)
+ setupColumnResizing();
+
+ // Shutdown cancel
+ document.getElementById('cancelShutdownBtn').addEventListener('click', async () => {
+ await window.api.cancelShutdown();
+ if (shutdownCountdownInterval) { clearInterval(shutdownCountdownInterval); shutdownCountdownInterval = null; }
+ document.getElementById('shutdownOverlay').style.display = 'none';
+ });
+
+ // Click on empty area in queue → deselect all
+ document.getElementById('upload-view').addEventListener('click', (e) => {
+ if (e.target.closest('.view-main') && !e.target.closest('.queue-row') && !e.target.closest('.btn') && !e.target.closest('.context-menu') && !e.target.closest('.recent-files-panel')) {
+ if (selectedJobIds.size > 0) {
+ selectedJobIds.clear();
+ renderQueueTable();
+ updateQueueActionButtons();
+ }
+ }
+ });
+
+ // Right-click on upload view background
+ document.getElementById('upload-view').addEventListener('contextmenu', (e) => {
+ if (e.target.closest('.queue-row')) return; // handled per row
+ if (queueJobs.length === 0 && selectedFiles.length === 0) return; // nothing in queue
+ e.preventDefault();
+ showContextMenu(e.clientX, e.clientY);
+ });
+
+ document.getElementById('hosterModal').addEventListener('click', (e) => {
+ if (e.target.id === 'hosterModal') cancelHosterModal();
+ });
+
+ // Account management
+ document.getElementById('addAccountBtn').addEventListener('click', () => openAccountModal(null));
+ document.getElementById('closeAccountModalBtn').addEventListener('click', closeAccountModal);
+ document.getElementById('cancelAccountModalBtn').addEventListener('click', closeAccountModal);
+ document.getElementById('saveAccountBtn').addEventListener('click', saveAccount);
+ document.getElementById('accountModal').addEventListener('click', (e) => {
+ if (e.target.id === 'accountModal') closeAccountModal();
+ });
+
+ // Account hoster select change → update credential fields
+ document.getElementById('accountHosterSelect').addEventListener('change', (e) => {
+ _invalidateAccountSubmit();
+ const opt = HOSTER_ADD_OPTIONS.find(o => o.value === e.target.value);
+ const authType = opt ? opt.authType : 'login';
+ const credsContainer = document.getElementById('accountCredsFields');
+ credsContainer.innerHTML = getCredsFieldsHtml(authType, {}, e.target.value);
+ wireCredentialVisibilityButtons(credsContainer);
+ _wireCredFieldInvalidation();
+ });
+
+ // Delete account modal
+ document.getElementById('closeDeleteModalBtn').addEventListener('click', closeDeleteModal);
+ document.getElementById('cancelDeleteBtn').addEventListener('click', closeDeleteModal);
+ document.getElementById('confirmDeleteBtn').addEventListener('click', () => {
+ const modal = document.getElementById('deleteAccountModal');
+ const accountId = modal.dataset.accountId;
+ if (accountId) deleteAccount(accountId);
+ });
+ document.getElementById('deleteAccountModal').addEventListener('click', (e) => {
+ if (e.target.id === 'deleteAccountModal') closeDeleteModal();
+ });
+
+ // Job log modal
+ document.getElementById('closeJobLogBtn')?.addEventListener('click', hideJobLogModal);
+ document.getElementById('closeJobLogBtn2')?.addEventListener('click', hideJobLogModal);
+ document.getElementById('copyJobLogBtn')?.addEventListener('click', copyJobLogToClipboard);
+ document.getElementById('jobLogModal')?.addEventListener('click', (e) => {
+ if (e.target.id === 'jobLogModal') hideJobLogModal();
+ });
+
+ document.getElementById('headerUpdateBtn')?.addEventListener('click', requestUpdateCheck);
+ document.getElementById('installUpdateBtn')?.addEventListener('click', installKnownUpdate);
+ document.getElementById('dismissUpdateBtn')?.addEventListener('click', closeUpdateDialog);
+ document.getElementById('updateCloseBtn')?.addEventListener('click', closeUpdateDialog);
+ document.getElementById('updateBanner')?.addEventListener('click', (event) => {
+ if (event.target.id === 'updateBanner') closeUpdateDialog();
+ });
+ document.addEventListener('keydown', _handleUpdateDialogKeydown, true);
+ _syncHeaderUpdateState();
+}
+
+// --- Update UI ---
+function showUpdateBanner(info) {
+ if (!info) return;
+ _knownUpdateInfo = { ...info, available: true };
+ if (_updateInstallBusy) {
+ _syncHeaderUpdateState();
+ _setUpdateDialogVisible(true);
+ return;
+ }
+ _updateInstallBusy = false;
+ const version = String(info.remoteVersion || '').replace(/^v/i, '') || 'unbekannt';
+ const title = document.getElementById('updateDialogTitle');
+ const message = document.getElementById('updateMessage');
+ const notes = document.getElementById('updateReleaseNotes');
+ const installButton = document.getElementById('installUpdateBtn');
+ if (title) title.textContent = 'Eine neue Version ist verfügbar';
+ if (message) message.textContent = `Update v${version} verfügbar`;
+ if (notes) {
+ const releaseNotes = String(info.releaseNotes || '').trim();
+ notes.textContent = releaseNotes.length > 2400 ? `${releaseNotes.slice(0, 2399)}…` : releaseNotes;
+ notes.hidden = !releaseNotes;
+ }
+ if (installButton) {
+ installButton.disabled = false;
+ installButton.textContent = 'Jetzt updaten';
+ }
+ _setUpdateProgress(0, 'Bereit zum Download');
+ _setUpdateDialogBusy(false);
+ _syncHeaderUpdateState();
+ _setUpdateDialogVisible(true);
+}
+
+function handleUpdateProgress(data) {
+ const progress = data || {};
+ const message = document.getElementById('updateMessage');
+ const button = document.getElementById('installUpdateBtn');
+ if (progress.stage === 'starting') {
+ _updateInstallBusy = true;
+ _setUpdateDialogBusy(true);
+ _setUpdateProgress(0, 'Download 0%');
+ if (message) message.textContent = 'Download wird vorbereitet…';
+ if (button) button.textContent = 'Download 0%';
+ } else if (progress.stage === 'downloading') {
+ const percent = Math.max(0, Math.min(100, Math.round(Number(progress.percent) || 0)));
+ _updateInstallBusy = true;
+ _setUpdateDialogBusy(true);
+ _setUpdateProgress(percent, `Download ${percent}%`);
+ if (message) message.textContent = `Update wird heruntergeladen… ${percent}%`;
+ if (button) button.textContent = `Download ${percent}%`;
+ } else if (progress.stage === 'verifying') {
+ _updateInstallBusy = true;
+ _setUpdateDialogBusy(true);
+ _setUpdateProgress(100, 'Prüfen…');
+ if (message) message.textContent = 'Download wird geprüft…';
+ if (button) button.textContent = 'Prüfen…';
+ } else if (progress.stage === 'prepared') {
+ _updateInstallBusy = true;
+ _setUpdateDialogBusy(true);
+ _setUpdateProgress(100, 'Neustart…');
+ if (message) message.textContent = 'Update ist bereit. Einstellungen werden gespeichert…';
+ if (button) button.textContent = 'Neustart…';
+ } else if (progress.stage === 'launching' || progress.stage === 'done') {
+ _updateInstallBusy = true;
+ _setUpdateDialogBusy(true);
+ _setUpdateProgress(100, 'Neustart…');
+ if (message) message.textContent = progress.stage === 'done' ? 'Update installiert. Die Anwendung startet neu…' : 'Update wird installiert. Die Anwendung startet neu…';
+ if (button) button.textContent = 'Neustart…';
+ } else if (progress.stage === 'error') {
+ _updateInstallBusy = false;
+ _setUpdateDialogBusy(false);
+ _setUpdateProgress(0, 'Update fehlgeschlagen');
+ if (message) message.textContent = `Update fehlgeschlagen: ${String(progress.error || 'Unbekannter Fehler').slice(0, 400)}`;
+ if (button) {
+ button.disabled = false;
+ button.textContent = 'Wiederholen';
+ }
+ _setUpdateDialogVisible(true);
+ }
+}
+
+function _isUpdateDialogVisible() {
+ const overlay = document.getElementById('updateBanner');
+ return Boolean(overlay && overlay.style.display !== 'none' && overlay.getAttribute('aria-hidden') !== 'true');
+}
+
+function _setUpdateBackgroundInert(active) {
+ const overlay = document.getElementById('updateBanner');
+ if (!overlay) return;
+ if (active) {
+ if (_updateDialogInertState.length > 0) return;
+ _updateDialogInertState = Array.from(document.body.children)
+ .filter(element => element !== overlay && 'inert' in element)
+ .map(element => ({ element, inert: element.inert }));
+ _updateDialogInertState.forEach(({ element }) => { element.inert = true; });
+ return;
+ }
+ _updateDialogInertState.forEach(({ element, inert }) => {
+ if (element.isConnected) element.inert = inert;
+ });
+ _updateDialogInertState = [];
+}
+
+function _getUpdateDialogFocusable() {
+ const dialog = document.querySelector('#updateBanner .update-dialog');
+ if (!dialog) return [];
+ return Array.from(dialog.querySelectorAll('button:not([disabled]), input:not([disabled]), select:not([disabled]), textarea:not([disabled]), [href], [tabindex]:not([tabindex="-1"])'))
+ .filter(element => !element.hidden && element.getClientRects().length > 0 && window.getComputedStyle(element).visibility !== 'hidden');
+}
+
+function _focusUpdateDialog() {
+ const dialog = document.querySelector('#updateBanner .update-dialog');
+ if (!dialog) return;
+ const target = _getUpdateDialogFocusable()[0] || dialog;
+ target.focus();
+}
+
+function _handleUpdateDialogKeydown(event) {
+ if (!_isUpdateDialogVisible()) return;
+ const dialog = document.querySelector('#updateBanner .update-dialog');
+ if (!dialog) return;
+ if (event.key === 'Escape') {
+ event.preventDefault();
+ event.stopImmediatePropagation();
+ if (!_updateInstallBusy) closeUpdateDialog();
+ return;
+ }
+ if (event.key !== 'Tab') {
+ if (!dialog.contains(event.target)) {
+ event.preventDefault();
+ event.stopImmediatePropagation();
+ _focusUpdateDialog();
+ }
+ return;
+ }
+ const focusable = _getUpdateDialogFocusable();
+ if (focusable.length === 0) {
+ event.preventDefault();
+ event.stopImmediatePropagation();
+ dialog.focus();
+ return;
+ }
+ const first = focusable[0];
+ const last = focusable[focusable.length - 1];
+ const activeElement = document.activeElement;
+ if (!dialog.contains(activeElement) || (!event.shiftKey && activeElement === last) || (event.shiftKey && activeElement === first)) {
+ event.preventDefault();
+ event.stopImmediatePropagation();
+ (event.shiftKey ? last : first).focus();
+ }
+}
+
+function _setUpdateDialogVisible(visible) {
+ const overlay = document.getElementById('updateBanner');
+ if (!overlay) return;
+ if (visible) {
+ const wasVisible = _isUpdateDialogVisible();
+ if (!wasVisible) {
+ _updateDialogReturnFocus = document.activeElement instanceof HTMLElement ? document.activeElement : null;
+ _setUpdateBackgroundInert(true);
+ }
+ overlay.style.display = 'flex';
+ overlay.setAttribute('aria-hidden', 'false');
+ requestAnimationFrame(() => {
+ const dialog = overlay.querySelector('.update-dialog');
+ if (_isUpdateDialogVisible() && dialog && !dialog.contains(document.activeElement)) _focusUpdateDialog();
+ });
+ } else {
+ overlay.style.display = 'none';
+ overlay.setAttribute('aria-hidden', 'true');
+ _setUpdateBackgroundInert(false);
+ const returnFocus = _updateDialogReturnFocus;
+ _updateDialogReturnFocus = null;
+ if (returnFocus && returnFocus.isConnected && typeof returnFocus.focus === 'function') returnFocus.focus();
+ }
+}
+
+function closeUpdateDialog() {
+ if (_updateInstallBusy) return false;
+ _setUpdateDialogVisible(false);
+ return true;
+}
+
+function _setUpdateDialogBusy(busy) {
+ const dialog = document.querySelector('#updateBanner .update-dialog');
+ if (dialog) dialog.setAttribute('aria-busy', busy ? 'true' : 'false');
+ ['installUpdateBtn', 'dismissUpdateBtn', 'updateCloseBtn'].forEach(id => {
+ const button = document.getElementById(id);
+ if (button) button.disabled = busy;
+ });
+ if (busy && dialog && (!dialog.contains(document.activeElement) || document.activeElement.matches?.(':disabled'))) dialog.focus();
+}
+
+function _setUpdateProgress(percent, text) {
+ const value = Math.max(0, Math.min(100, Math.round(Number(percent) || 0)));
+ const progressText = document.getElementById('updateProgressText');
+ const progressBar = document.getElementById('updateProgressBar');
+ if (progressText) progressText.textContent = text;
+ if (progressBar) {
+ progressBar.setAttribute('aria-valuenow', String(value));
+ progressBar.setAttribute('aria-valuetext', String(text || `${value}%`));
+ if ('value' in progressBar) progressBar.value = value;
+ progressBar.style.width = `${value}%`;
+ }
+}
+
+async function installKnownUpdate() {
+ if (_updateInstallBusy) return;
+ if (!_knownUpdateInfo || !_knownUpdateInfo.available) {
+ await requestUpdateCheck();
+ return;
+ }
+ _updateInstallBusy = true;
+ _setUpdateDialogBusy(true);
+ _setUpdateProgress(0, 'Download 0%');
+ const message = document.getElementById('updateMessage');
+ const button = document.getElementById('installUpdateBtn');
+ if (message) message.textContent = 'Download wird vorbereitet…';
+ if (button) button.textContent = 'Download 0%';
+ try {
+ await persistQueueStateNow();
+ const result = await window.api.installUpdate();
+ if (result && result.started === false) throw new Error(result.error || 'Update konnte nicht gestartet werden');
+ } catch (error) {
+ handleUpdateProgress({ stage: 'error', error: error && error.message ? error.message : String(error) });
+ }
+}
+
+// --- Shutdown ---
+let shutdownCountdownInterval = null;
+function handleShutdownCountdown(data) {
+ const overlay = document.getElementById('shutdownOverlay');
+ const msgEl = document.getElementById('shutdownMessage');
+ const secEl = document.getElementById('shutdownSeconds');
+ overlay.style.display = 'flex';
+
+ const labels = { sleep: 'Ruhezustand', shutdown: 'Herunterfahren', restart: 'Neustart' };
+ let remaining = data.seconds || 60;
+ secEl.textContent = remaining;
+ msgEl.textContent = `${labels[data.mode] || data.mode} in ${remaining}s...`;
+
+ if (shutdownCountdownInterval) clearInterval(shutdownCountdownInterval);
+ shutdownCountdownInterval = setInterval(() => {
+ remaining--;
+ secEl.textContent = remaining;
+ msgEl.textContent = `${labels[data.mode] || data.mode} in ${remaining}s...`;
+ if (remaining <= 0) { clearInterval(shutdownCountdownInterval); }
+ }, 1000);
+}
+
+// --- Auto-deduplicate restored queue against own upload log on startup ---
+async function _autoDeduplicateFromLog() {
+ if (queueJobs.length === 0 && selectedFiles.length === 0) return;
+ try {
+ const entries = await window.api.readOwnUploadLog();
+ if (!entries || entries.length === 0) return;
+ // Drops 'done' jobs present in the log (declutter) AND any job that the log
+ // shows completed at/after the snapshot's savedAt (a stale 'preview' ghost).
+ // Pending jobs matching only OLDER log lines survive — intentional re-uploads.
+ // Decision lives in lib/queue-dedup.js (Node-tested, see tests/queue-dedup.test.js)
+ // so it can't silently regress to nuking the whole restored queue on restart.
+ const { kept, removed } = window.QueueDedup.partitionRestoredJobsByLog(queueJobs, entries, _restoredSnapshotSavedAt);
+ if (removed.length > 0) {
+ queueJobs = kept;
+ for (const job of removed) {
+ if (job.file && job.hoster) _completedUploadKeys.add(`${job.file}|${job.hoster}`);
+ }
+ rebuildJobIndex();
+ syncSelectedFilesFromQueue();
+ window.api.debugLog(`auto-dedup: removed ${removed.length} already-uploaded (done) jobs from restored queue (${entries.length} log entries)`);
+ }
+ const seedKeys = window.QueueDedup.completedSelectionKeys(selectedFiles, getSelectedHosters(), entries, _restoredSnapshotSavedAt);
+ if (seedKeys.length > 0) {
+ for (const k of seedKeys) _completedUploadKeys.add(k);
+ window.api.debugLog(`auto-dedup: seeded ${seedKeys.length} completed file|hoster keys from log so buildQueuePreview won't re-create ghosts`);
+ }
+ } catch {}
+}
+
+// --- Log import: remove already-uploaded file+hoster combos from queue ---
+async function importUploadLog() {
+ const result = await window.api.importUploadLog();
+ if (!result || result.canceled) return;
+ const entries = result.entries || [];
+ if (entries.length === 0) {
+ showCopyToast('Keine Einträge im Log gefunden');
+ return;
+ }
+
+ // Build lookup Set: "filename_lower|hoster"
+ const logKeys = new Set();
+ for (const entry of entries) {
+ logKeys.add(`${entry.fileName.toLowerCase()}|${entry.hoster.toLowerCase()}`);
+ }
+
+ // Find queue jobs that match (already uploaded)
+ let removed = 0;
+ queueJobs = queueJobs.filter(job => {
+ const key = `${job.fileName.toLowerCase()}|${job.hoster.toLowerCase()}`;
+ if (logKeys.has(key) && job.status !== 'done') {
+ removeJobFromIndex(job);
+ // Mark as completed so buildQueuePreview won't re-create them
+ if (job.file && job.hoster) _completedUploadKeys.add(`${job.file}|${job.hoster}`);
+ removed++;
+ return false;
+ }
+ return true;
+ });
+
+ if (removed > 0) {
+ selectedJobIds.clear();
+ syncSelectedFilesFromQueue();
+ rebuildJobIndex();
+ renderQueueTable();
+ updateUploadView();
+ updateStatusBar();
+ persistQueueStateSoon(true);
+ }
+
+ showCopyToast(`${removed} bereits hochgeladene Jobs aus Queue entfernt (${entries.length} Log-Einträge gelesen)`);
+}
+
+// --- Link operations ---
+function copyAllLinks() {
+ const rows = queueJobs
+ .filter(j => j.status === 'done' && j.result)
+ .map(j => ({
+ fileName: j.fileName || '',
+ hoster: j.hoster || '',
+ url: j.result.download_url || j.result.embed_url || ''
+ }))
+ .filter(r => r.url);
+ if (rows.length === 0) return;
+ const formatEl = document.getElementById('linkExportFormat');
+ const fmt = (formatEl && formatEl.value) || 'plain';
+ const text = window.Stats ? window.Stats.formatLinks(rows, fmt) : rows.map(r => r.url).join('\n');
+ window.api.copyToClipboard(text);
+ showCopyToast(`${rows.length} Link${rows.length === 1 ? '' : 's'} als ${fmt.toUpperCase()} kopiert`);
+}
+
+// --- Utilities ---
+function formatSize(bytes) {
+ if (!bytes || bytes <= 0) return '0 B';
+ if (bytes < 1024) return bytes + ' B';
+ if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + ' kB';
+ if (bytes < 1024 * 1024 * 1024) return (bytes / (1024 * 1024)).toFixed(1) + ' MB';
+ return (bytes / (1024 * 1024 * 1024)).toFixed(2) + ' GB';
+}
+
+function formatSpeed(kbs) {
+ if (!kbs || kbs <= 0) return '0 kB/s';
+ if (kbs >= 1024) return (kbs / 1024).toFixed(1) + ' MB/s';
+ return Math.round(kbs) + ' kB/s';
+}
+
+function formatTime(seconds) {
+ if (!seconds || seconds <= 0) return '00:00';
+ const h = Math.floor(seconds / 3600);
+ const m = Math.floor((seconds % 3600) / 60);
+ const s = seconds % 60;
+ if (h > 0) return `${pad(h)}:${pad(m)}:${pad(s)}`;
+ return `${pad(m)}:${pad(s)}`;
+}
+
+function pad(n) { return String(Math.floor(n)).padStart(2, '0'); }
+
+function formatDateTime(value) {
+ const date = value instanceof Date ? value : new Date(value);
+ const safeDate = Number.isNaN(date.getTime()) ? new Date() : date;
+ return {
+ ts: safeDate.getTime(),
+ text: safeDate.toLocaleDateString('de-DE', { day: '2-digit', month: '2-digit', year: 'numeric' })
+ + ' ' + safeDate.toLocaleTimeString('de-DE', { hour: '2-digit', minute: '2-digit', second: '2-digit' })
+ };
+}
+
+function loadAutoCheckPreference() {
+ try { const r = localStorage.getItem(AUTO_CHECK_PREF_KEY); return r === null || r === '1'; }
+ catch { return true; }
+}
+
+// --- Queue table column resizing (JDownloader-style) ---
+// Two-tier widths: _idealColumnWidths is what the user set (persisted); the
+// displayed widths are scaled proportionally if the window is too narrow to fit
+// all ideals (fullscreen → windowed). We never overwrite ideals just because
+// the window shrunk — only an explicit drag updates the ideal for that column.
+const _idealColumnWidths = {};
+
+function restoreQueueColumnWidths() {
+ try {
+ const raw = localStorage.getItem(QUEUE_COL_WIDTHS_KEY);
+ if (raw) {
+ const widths = JSON.parse(raw);
+ if (widths && typeof widths === 'object') {
+ for (const [col, px] of Object.entries(widths)) {
+ if (typeof px === 'number' && px > 20) _idealColumnWidths[col] = px;
+ }
+ }
+ }
+ _applyFittedColumnWidths();
+ } catch {}
+}
+
+function saveDraggedColumnWidth(col, width) {
+ // Called from the resizer onUp: the dragged column's new width becomes its
+ // new ideal. Other columns keep their saved ideals untouched (so a drag
+ // while the window is small doesn't bake the scaled values in).
+ if (!col || typeof width !== 'number' || width < 40) return;
+ _idealColumnWidths[col] = width;
+ try { localStorage.setItem(QUEUE_COL_WIDTHS_KEY, JSON.stringify(_idealColumnWidths)); } catch {}
+ _applyFittedColumnWidths();
+}
+
+function _applyFittedColumnWidths() {
+ const container = document.getElementById('queueContainer');
+ if (!container) return;
+ const ths = document.querySelectorAll('#queueTable th[data-col]');
+ if (!ths.length) return;
+
+ const entries = [];
+ let total = 0;
+ ths.forEach(th => {
+ // Fall back to the column's currently-measured width if no ideal exists
+ // yet (first render before the user ever dragged).
+ const ideal = _idealColumnWidths[th.dataset.col] || th.getBoundingClientRect().width || 0;
+ entries.push({ th, ideal });
+ total += ideal;
+ });
+ if (total <= 0) return;
+
+ const available = container.clientWidth;
+ if (available <= 0) return;
+ const MIN = 40;
+
+ if (total <= available) {
+ entries.forEach(({ th, ideal }) => { th.style.width = ideal + 'px'; });
+ return;
+ }
+ // Scale all columns proportionally so they exactly fit the available width.
+ const scale = available / total;
+ entries.forEach(({ th, ideal }) => {
+ th.style.width = Math.max(MIN, Math.round(ideal * scale)) + 'px';
+ });
+}
+
+// Debounced window-resize refit. Fires on every window size change — fullscreen
+// → windowed, dragging the window edge, monitor unplug — and reshapes columns
+// to the new viewport so the user never has to drag the window wider just to
+// see a hidden column.
+let _columnRefitTimer = null;
+window.addEventListener('resize', () => {
+ clearTimeout(_columnRefitTimer);
+ _columnRefitTimer = setTimeout(_applyFittedColumnWidths, 60);
+});
+
+function setupColumnResizing() {
+ const headers = document.querySelectorAll('#queueTable th[data-col]');
+ headers.forEach(th => {
+ const resizer = th.querySelector('.col-resizer');
+ if (!resizer) return;
+
+ resizer.addEventListener('mousedown', (e) => {
+ e.preventDefault();
+ e.stopPropagation();
+
+ const startX = e.clientX;
+ const startWidth = th.getBoundingClientRect().width;
+ resizer.classList.add('dragging');
+ document.body.classList.add('col-resizing');
+
+ const onMove = (ev) => {
+ const delta = ev.clientX - startX;
+ const newWidth = Math.max(40, startWidth + delta);
+ th.style.width = newWidth + 'px';
+ };
+
+ const onUp = () => {
+ document.removeEventListener('mousemove', onMove);
+ document.removeEventListener('mouseup', onUp);
+ resizer.classList.remove('dragging');
+ document.body.classList.remove('col-resizing');
+ // Only the dragged column's new width becomes its new ideal; other
+ // columns keep their saved ideals (so dragging while the window is
+ // narrow doesn't permanently shrink everything else).
+ saveDraggedColumnWidth(th.dataset.col, th.getBoundingClientRect().width);
+ };
+
+ document.addEventListener('mousemove', onMove);
+ document.addEventListener('mouseup', onUp);
+ });
+ });
+}
+
+// Single-pass escape instead of 4 chained .replace(/x/g, ...) calls.
+// Hot path on large table rebuilds — every text cell runs through one of these.
+const _HTML_ESC_MAP = { '&': '&', '<': '<', '>': '>', '"': '"' };
+const _HTML_ESC_RE = /[&<>"]/g;
+const _ATTR_ESC_MAP = { '&': '&', '"': '"', "'": ''' };
+const _ATTR_ESC_RE = /[&"']/g;
+
+function escapeHtml(str) {
+ if (!str) return '';
+ return String(str).replace(_HTML_ESC_RE, (c) => _HTML_ESC_MAP[c]);
+}
+
+function escapeAttr(str) {
+ if (!str) return '';
+ return String(str).replace(_ATTR_ESC_RE, (c) => _ATTR_ESC_MAP[c]);
+}
+
+function showCopyToast(msg, durationMs) {
+ const toast = document.getElementById('copyToast');
+ toast.textContent = msg;
+ toast.classList.add('show');
+ clearTimeout(toast._timer);
+ toast._timer = setTimeout(() => toast.classList.remove('show'), durationMs || 1500);
+}
+
+// --- Resize handle for recent-files panel ---
+{
+ const resizer = document.getElementById('recentFilesResizer');
+ const panel = document.getElementById('recentFilesPanel');
+ if (resizer && panel) {
+ let startY = 0;
+ let startH = 0;
+
+ resizer.addEventListener('mousedown', (e) => {
+ e.preventDefault();
+ startY = e.clientY;
+ startH = panel.getBoundingClientRect().height;
+ resizer.classList.add('dragging');
+ document.body.style.cursor = 'ns-resize';
+ document.body.style.userSelect = 'none';
+
+ const onMove = (e2) => {
+ const delta = startY - e2.clientY;
+ const newH = Math.max(60, Math.min(window.innerHeight * 0.7, startH + delta));
+ panel.style.flex = `0 0 ${newH}px`;
+ };
+
+ const onUp = () => {
+ document.removeEventListener('mousemove', onMove);
+ document.removeEventListener('mouseup', onUp);
+ resizer.classList.remove('dragging');
+ document.body.style.cursor = '';
+ document.body.style.userSelect = '';
+ };
+
+ document.addEventListener('mousemove', onMove);
+ document.addEventListener('mouseup', onUp);
+ });
+ }
+}
+
+// --- Recent panel tabs ---
+document.querySelectorAll('.recent-tab').forEach(tab => {
+ tab.addEventListener('click', () => {
+ document.querySelectorAll('.recent-tab').forEach(t => t.classList.remove('active'));
+ document.querySelectorAll('.recent-tab-body').forEach(b => b.classList.remove('active'));
+ tab.classList.add('active');
+ const panel = document.getElementById(tab.dataset.panel);
+ if (panel) panel.classList.add('active');
+ const hint = document.getElementById('recentFilesHint');
+ if (hint) hint.textContent = tab.dataset.panel === 'statsTab' ? 'Upload-Statistiken' : 'Zuletzt erzeugte Upload-Links';
+ });
+});
+
+// --- Stats panel update ---
+let statsStartTime = 0;
+let statsRunTimer = null;
+
+function formatBytes(bytes) {
+ if (bytes <= 0) return '0 B';
+ const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+ const i = Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), units.length - 1);
+ return (bytes / Math.pow(1024, i)).toFixed(i > 0 ? 2 : 0) + ' ' + units[i];
+}
+
+function formatDuration(seconds) {
+ const h = Math.floor(seconds / 3600);
+ const m = Math.floor((seconds % 3600) / 60);
+ const s = seconds % 60;
+ return `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}:${String(s).padStart(2, '0')}`;
+}
+
+function updateStatsPanel() {
+ const stats = _computeQueueStats();
+ const remaining = stats.total - stats.done - stats.errors;
+
+ const el = (id) => document.getElementById(id);
+ if (el('statQueueTotal')) el('statQueueTotal').textContent = stats.total;
+ if (el('statQueueDone')) el('statQueueDone').textContent = stats.done;
+ if (el('statQueueRemaining')) el('statQueueRemaining').textContent = remaining;
+ if (el('statQueueInProgress')) el('statQueueInProgress').textContent = stats.inProgress;
+ if (el('statQueueError')) el('statQueueError').textContent = stats.errors;
+ if (el('statSizeTotal')) el('statSizeTotal').textContent = formatBytes(stats.totalSize);
+ if (el('statSizeRemaining')) el('statSizeRemaining').textContent = formatBytes(stats.remainingSize);
+
+ const speed = lastUploadStats.globalSpeedKbs || 0;
+ if (el('statSpeed')) el('statSpeed').textContent = speed > 0 ? formatBytes(speed * 1024) + '/s' : '0 B/s';
+ if (el('statEta')) {
+ if (speed > 0 && stats.remainingSize > 0) {
+ el('statEta').textContent = formatDuration(Math.round(stats.remainingSize / (speed * 1024)));
+ } else {
+ el('statEta').textContent = '--:--';
+ }
+ }
+ if (el('statSessionBytes')) el('statSessionBytes').textContent = formatBytes(lastUploadStats.totalBytes || 0);
+}
+
+// --- Start ---
+window.api.onPrepareClose(prepareForWindowClose);
+init().then(() => {
+ window.api.signalCloseHandshakeReady();
+}).catch((err) => {
+ try {
+ if (window.api && window.api.debugLog) window.api.debugLog(`init failed: ${err && err.stack ? err.stack : err}`);
+ const root = document.getElementById('app') || document.body;
+ if (root) {
+ const banner = document.createElement('div');
+ banner.style.cssText = 'position:fixed;top:0;left:0;right:0;background:#5a1e1e;color:#fff;padding:8px;z-index:99999;font-family:sans-serif;font-size:13px';
+ banner.textContent = 'Initialisierung fehlgeschlagen: ' + (err && err.message ? err.message : err) + ' — bitte Diagnose-Paket exportieren oder Programm neu starten.';
+ root.appendChild(banner);
+ }
+ } catch {}
+});
diff --git a/renderer/drop-target.html b/renderer/drop-target.html
new file mode 100644
index 0000000..399dfd1
--- /dev/null
+++ b/renderer/drop-target.html
@@ -0,0 +1,92 @@
+
+
+
+
+
+
+
+
+
+
+
diff --git a/renderer/index.html b/renderer/index.html
new file mode 100644
index 0000000..e0081ca
--- /dev/null
+++ b/renderer/index.html
@@ -0,0 +1,622 @@
+
+
+
+
+
+
+ Multi-Hoster-Upload
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Eine neue Version ist verfügbar
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Dateien hierher ziehen oder klicken
+
Dateien und Ordner werden vor dem Upload geprüft.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ | Dateiname |
+ Hochgeladen / Größe |
+ Hoster |
+ Status |
+ Zeit |
+ Rest |
+ Geschwindigkeit |
+ Fortschritt |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ | Datum▼ |
+ Dateiname↕ |
+ Hoster↕ |
+ Link↕ |
+
+
+
+
+
+
+
+
+
+
Dateien in der Warteschlange
+
Gesamt:0
+
Fertig:0
+
Verbleibend:0
+
Läuft:0
+
Fehler:0
+
+
+
Dateigröße in der Warteschlange
+
Gesamt:0 B
+
Verbleibend:0 B
+
+
+
Sitzung
+
Upload-Geschwindigkeit:0 B/s
+
Restzeit:--:--
+
Laufzeit:00:00:00
+
In diesem Lauf hochgeladen:0 B
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Account wirklich löschen?
+
+
+
+
+ Bereit
+ |
+ 0 kB/s
+ |
+ 0 B
+ |
+ ETA --:--
+ |
+ Verbindungen 0
+ |
+ Gesamt 0
+ |
+ Verbleibend 0
+ |
+ Läuft 0
+ |
+ Fertig 0
+ |
+ Fehler 0
+
+
+
+
+
+
+
System wird heruntergefahren in 60s...
+
+
+
no form here
'), {});
+ assert.deepEqual(up._parseUploadFormFields(''), {});
+});
+
+// --- deriveApiKey: pull + validate the account API key from the web session ---
+test('_extractApiKeyCandidates finds the key in an input value and ranks api-context first', () => {
+ const up = new DoodstreamUploader();
+ const html = `
+
+ API Key
+ `;
+ const cands = up._extractApiKeyCandidates(html);
+ // The token whose preceding context mentions "API" must rank first.
+ assert.equal(cands[0], 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb');
+ assert.ok(cands.includes('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'));
+});
+
+test('_extractApiKeyCandidates handles textarea + api_key: "x" shapes and empty input', () => {
+ const up = new DoodstreamUploader();
+ assert.deepEqual(up._extractApiKeyCandidates(''), []);
+ const ta = up._extractApiKeyCandidates('');
+ assert.ok(ta.includes('cccccccccccccccccccccccccccccccc'));
+ const js = up._extractApiKeyCandidates('var x = {"api_key":"dddddddddddddddddddddddddddddddd"};');
+ assert.ok(js.includes('dddddddddddddddddddddddddddddddd'));
+});
+
+test('deriveApiKey returns the candidate that validates against the API', async () => {
+ const up = new DoodstreamUploader();
+ up._fetch = async () => ({ text: async () => 'API Key
' });
+ up._validateApiKey = async (key) => key === 'REALKEY1234567890abcdefGHIJK';
+ const key = await up.deriveApiKey();
+ assert.equal(key, 'REALKEY1234567890abcdefGHIJK');
+ assert.equal(up.apiKey, 'REALKEY1234567890abcdefGHIJK'); // cached on the instance
+});
+
+test('deriveApiKey returns null when no candidate validates (→ caller uses web fallback)', async () => {
+ const up = new DoodstreamUploader();
+ up._fetch = async () => ({ text: async () => '' });
+ up._validateApiKey = async () => false;
+ assert.equal(await up.deriveApiKey(), null);
+ assert.equal(up.apiKey, '');
+});
+
+test('deriveApiKey short-circuits when a key is already set', async () => {
+ const up = new DoodstreamUploader();
+ up.apiKey = 'PRESET';
+ let fetched = false;
+ up._fetch = async () => { fetched = true; return { text: async () => '' }; };
+ assert.equal(await up.deriveApiKey(), 'PRESET');
+ assert.equal(fetched, false);
+});
+
+// --- _fetch: transient network blips on the small requests self-heal ---
+test('_fetch retries a transient network failure then succeeds', async () => {
+ const up = new DoodstreamUploader();
+ const origFetch = globalThis.fetch;
+ let calls = 0;
+ globalThis.fetch = async () => {
+ calls++;
+ if (calls === 1) throw new TypeError('fetch failed');
+ return { status: 200, headers: { getSetCookie: () => [], get: () => null }, text: async () => 'ok' };
+ };
+ try {
+ const res = await up._fetch('https://example.test/x');
+ assert.equal(calls, 2); // failed once, retried, succeeded
+ assert.equal(await res.text(), 'ok');
+ } finally {
+ globalThis.fetch = origFetch;
+ }
+});
+
+// --- _getUploadServer: discovery must never fall back to a hardcoded node ---
+function fakeRes(body, { status = 200, ctype = 'text/html' } = {}) {
+ return { status, headers: { get: (h) => (h.toLowerCase() === 'content-type' ? ctype : null) }, text: async () => body };
+}
+
+test('getUploadServer: returns JSON result when present', async () => {
+ const up = new DoodstreamUploader();
+ up._fetch = async (url) => {
+ assert.match(url, /op=upload_server/);
+ return fakeRes(JSON.stringify({ result: 'https://node42.cloudatacdn.com/upload/01' }), { ctype: 'application/json' });
+ };
+ assert.equal(await up._getUploadServer(), 'https://node42.cloudatacdn.com/upload/01');
+});
+
+test('getUploadServer: falls back to srv_url in upload-page HTML', async () => {
+ const up = new DoodstreamUploader();
+ up._fetch = async (url) => {
+ if (/op=upload_server/.test(url)) return fakeRes('not json');
+ return fakeRes('');
+ };
+ assert.equal(await up._getUploadServer(), 'https://node7.cloudatacdn.com/upload/01');
+});
+
+test('getUploadServer: parses current form-action node and refreshes sess_id from the same page', async () => {
+ const up = new DoodstreamUploader();
+ up.sessId = 'stale-from-login';
+ up._fetch = async (url) => {
+ if (/op=upload_server/.test(url)) return fakeRes('not json');
+ return fakeRes('');
+ };
+ const url = await up._getUploadServer();
+ assert.equal(url, 'https://n9.cloudatacdn.com/upload/01?FRESH123');
+ assert.equal(up.sessId, 'FRESH123'); // critical: form-field token must match the node URL token
+});
+
+test('getUploadServer: un-escapes & in the form-action query string', async () => {
+ const up = new DoodstreamUploader();
+ up._fetch = async (url) => {
+ if (/op=upload_server/.test(url)) return fakeRes('not json');
+ return fakeRes('');
+ };
+ assert.equal(await up._getUploadServer(), 'https://n9.cloudatacdn.com/upload/01?a=1&b=2');
+});
+
+test('getUploadServer: throws (no silent dead fallback) when discovery fails', async () => {
+ const up = new DoodstreamUploader();
+ up._fetch = async () => fakeRes('login required', { status: 200 });
+ await assert.rejects(
+ () => up._getUploadServer(),
+ (err) => {
+ assert.match(err.message, /konnte Upload-Server nicht ermitteln/);
+ assert.doesNotMatch(err.message, /tr1128ve\.cloudatacdn\.com/); // never the hardcoded node
+ return true;
+ }
+ );
+});
diff --git a/tests/file-probe.test.js b/tests/file-probe.test.js
new file mode 100644
index 0000000..c792a52
--- /dev/null
+++ b/tests/file-probe.test.js
@@ -0,0 +1,115 @@
+const test = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { detectKind, isVideoLikeKind, probeFileHead, summarizeFileStat } = require('../lib/file-probe');
+
+function tmpWrite(name, buf) {
+ const p = path.join(os.tmpdir(), `mhu-probe-${Date.now()}-${name}`);
+ fs.writeFileSync(p, buf);
+ return p;
+}
+
+test('detectKind recognizes ISO-MP4 (ftyp box at offset 4)', () => {
+ const buf = Buffer.concat([Buffer.from([0x00, 0x00, 0x00, 0x20]), Buffer.from('ftypisom', 'ascii'), Buffer.alloc(8, 0)]);
+ assert.strictEqual(detectKind(buf), 'mp4-iso');
+ assert.strictEqual(isVideoLikeKind('mp4-iso'), true);
+});
+
+test('detectKind recognizes Matroska / WebM EBML header', () => {
+ const buf = Buffer.from([0x1A, 0x45, 0xDF, 0xA3, 0x01, 0x00]);
+ assert.strictEqual(detectKind(buf), 'matroska');
+ assert.strictEqual(isVideoLikeKind('matroska'), true);
+});
+
+test('detectKind recognizes AVI (RIFF...AVI )', () => {
+ const buf = Buffer.concat([Buffer.from('RIFF', 'ascii'), Buffer.from([0x00, 0x00, 0x00, 0x00]), Buffer.from('AVI ', 'ascii')]);
+ assert.strictEqual(detectKind(buf), 'avi');
+});
+
+test('detectKind recognizes FLV', () => {
+ const buf = Buffer.concat([Buffer.from('FLV', 'ascii'), Buffer.from([0x01])]);
+ assert.strictEqual(detectKind(buf), 'flv');
+});
+
+test('detectKind recognizes ASF (WMV)', () => {
+ const buf = Buffer.from([0x30, 0x26, 0xB2, 0x75, 0x00, 0x00]);
+ assert.strictEqual(detectKind(buf), 'asf-wmv');
+});
+
+test('detectKind recognizes MPEG-PS (00 00 01 BA)', () => {
+ const buf = Buffer.from([0x00, 0x00, 0x01, 0xBA, 0x00]);
+ assert.strictEqual(detectKind(buf), 'mpeg-ps');
+});
+
+test('detectKind recognizes JPEG (non-video)', () => {
+ const buf = Buffer.from([0xFF, 0xD8, 0xFF, 0xE0]);
+ assert.strictEqual(detectKind(buf), 'jpeg');
+ assert.strictEqual(isVideoLikeKind('jpeg'), false);
+});
+
+test('detectKind recognizes HTML response (non-video)', () => {
+ const buf = Buffer.from('', 'ascii');
+ assert.strictEqual(detectKind(buf), 'html');
+ assert.strictEqual(isVideoLikeKind('html'), false);
+});
+
+test('detectKind returns empty for zero-length and unknown for noise', () => {
+ assert.strictEqual(detectKind(Buffer.alloc(0)), 'empty');
+ assert.strictEqual(detectKind(Buffer.from([0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF])), 'unknown');
+});
+
+test('probeFileHead reads first bytes and returns hex + kind for an MP4-like file', async () => {
+ const mp4Head = Buffer.concat([Buffer.from([0x00, 0x00, 0x00, 0x20]), Buffer.from('ftypisom', 'ascii'), Buffer.alloc(16, 0xAA)]);
+ const p = tmpWrite('fake.mp4', mp4Head);
+ try {
+ const res = await probeFileHead(p, 64);
+ assert.strictEqual(res.ok, true);
+ assert.strictEqual(res.kind, 'mp4-iso');
+ assert.strictEqual(res.isVideoLike, true);
+ assert.ok(res.headHex.startsWith('0000002066747970'));
+ assert.strictEqual(res.bytesRead, mp4Head.length);
+ } finally {
+ fs.unlinkSync(p);
+ }
+});
+
+test('probeFileHead returns ok:false with kind=unreadable for missing file', async () => {
+ const res = await probeFileHead(path.join(os.tmpdir(), `does-not-exist-${Date.now()}.mp4`), 32);
+ assert.strictEqual(res.ok, false);
+ assert.strictEqual(res.kind, 'unreadable');
+ assert.ok(res.error);
+});
+
+test('summarizeFileStat returns size + mtime for a real file', () => {
+ const p = tmpWrite('stat.bin', Buffer.alloc(123, 0xCC));
+ try {
+ const stat = summarizeFileStat(p);
+ assert.strictEqual(stat.size, 123);
+ assert.strictEqual(stat.isFile, true);
+ assert.ok(stat.mtime);
+ } finally {
+ fs.unlinkSync(p);
+ }
+});
+
+test('summarizeFileStat returns error for missing file', () => {
+ const stat = summarizeFileStat(path.join(os.tmpdir(), `does-not-exist-${Date.now()}.bin`));
+ assert.ok(stat.error);
+});
+
+test('detectKind requires TS sync-byte periodicity — GIF and G-prefixed text are NOT mpeg-ts', () => {
+ const ts = Buffer.alloc(377, 0xFF);
+ ts[0] = 0x47; ts[188] = 0x47; ts[376] = 0x47;
+ assert.strictEqual(detectKind(ts), 'mpeg-ts');
+ assert.strictEqual(isVideoLikeKind('mpeg-ts'), true);
+
+ const gif = Buffer.concat([Buffer.from('GIF89a', 'ascii'), Buffer.alloc(400, 0x00)]);
+ assert.strictEqual(detectKind(gif), 'gif');
+ assert.strictEqual(isVideoLikeKind('gif'), false);
+
+ const gText = Buffer.concat([Buffer.from('Gewinnerliste 2026\n', 'ascii'), Buffer.alloc(400, 0x20)]);
+ assert.notStrictEqual(detectKind(gText), 'mpeg-ts');
+ assert.strictEqual(isVideoLikeKind(detectKind(gText)), false);
+});
diff --git a/tests/history-retention.test.js b/tests/history-retention.test.js
new file mode 100644
index 0000000..525ce95
--- /dev/null
+++ b/tests/history-retention.test.js
@@ -0,0 +1,95 @@
+const test = require('node:test');
+const assert = require('node:assert');
+const { applyHistoryRetention, countHistoryRows } = require('../lib/config-store');
+
+function batch(timestamp, okRows, extras = {}) {
+ const results = [];
+ for (let i = 0; i < okRows; i++) results.push({ status: 'success', hoster: 'voe.sx', download_url: `https://voe.sx/${i}` });
+ if (extras.aborted) for (let i = 0; i < extras.aborted; i++) results.push({ status: 'aborted', hoster: 'voe.sx' });
+ if (extras.error) for (let i = 0; i < extras.error; i++) results.push({ status: 'error', hoster: 'voe.sx' });
+ return { timestamp, files: [{ name: 'clip.mp4', results }] };
+}
+
+const DAY = 86400000;
+
+test('countHistoryRows counts every visible history result', () => {
+ const h = [batch('2026-01-01', 3, { aborted: 2, error: 1 })];
+ assert.strictEqual(countHistoryRows(h), 6);
+});
+
+test('count policy prunes histories made only from failed or aborted uploads', () => {
+ const h = [
+ batch('2026-01-01', 0, { error: 60 }),
+ batch('2026-01-02', 0, { aborted: 60 }),
+ batch('2026-01-03', 0, { error: 60 })
+ ];
+ const pruned = applyHistoryRetention(h, '100', Date.parse('2026-06-01'));
+ assert.deepStrictEqual(pruned.map(b => b.timestamp), ['2026-01-02', '2026-01-03']);
+ assert.strictEqual(countHistoryRows(pruned), 120);
+});
+
+test('retention "all" returns the array unchanged', () => {
+ const h = [batch('2026-01-01', 5), batch('2026-01-02', 5)];
+ assert.strictEqual(applyHistoryRetention(h, 'all', Date.parse('2026-06-01')), h);
+});
+
+test('count policy keeps newest whole batches up to the row target', () => {
+ const h = [batch('2026-01-01', 400), batch('2026-01-02', 400), batch('2026-01-03', 400)];
+ const pruned = applyHistoryRetention(h, '1000', Date.parse('2026-06-01'));
+ assert.strictEqual(pruned.length, 3);
+ assert.strictEqual(countHistoryRows(pruned), 1200);
+});
+
+test('count policy drops older batches once target reached (newest first)', () => {
+ const h = [batch('2026-01-01', 600), batch('2026-01-02', 600), batch('2026-01-03', 600)];
+ const pruned = applyHistoryRetention(h, '1000', Date.parse('2026-06-01'));
+ assert.strictEqual(pruned.length, 2);
+ assert.deepStrictEqual(pruned.map(b => b.timestamp), ['2026-01-02', '2026-01-03']);
+});
+
+test('count policy always keeps the newest batch even if it alone exceeds N', () => {
+ const h = [batch('2026-01-01', 50), batch('2026-01-02', 5000)];
+ const pruned = applyHistoryRetention(h, '100', Date.parse('2026-06-01'));
+ assert.strictEqual(pruned.length, 1);
+ assert.strictEqual(pruned[0].timestamp, '2026-01-02');
+});
+
+test('time policy drops batches older than the cutoff', () => {
+ const now = Date.parse('2026-06-15T00:00:00Z');
+ const h = [
+ batch(new Date(now - 10 * DAY).toISOString(), 5),
+ batch(new Date(now - 3 * DAY).toISOString(), 5),
+ batch(new Date(now - 1 * DAY).toISOString(), 5)
+ ];
+ const pruned = applyHistoryRetention(h, '7d', now);
+ assert.strictEqual(pruned.length, 2);
+});
+
+test('time policy keeps batches with missing or invalid timestamp', () => {
+ const now = Date.parse('2026-06-15T00:00:00Z');
+ const h = [
+ batch(undefined, 5),
+ batch('not-a-date', 5),
+ batch(new Date(now - 99 * DAY).toISOString(), 5),
+ batch(new Date(now - 1 * DAY).toISOString(), 5)
+ ];
+ const pruned = applyHistoryRetention(h, '30d', now);
+ assert.strictEqual(pruned.length, 3);
+ assert.ok(pruned.includes(h[0]));
+ assert.ok(pruned.includes(h[1]));
+ assert.ok(!pruned.includes(h[2]));
+});
+
+test('count policy shrinks a realistic 41-batch / >1000-row history', () => {
+ const h = [];
+ for (let i = 0; i < 41; i++) h.push(batch(`2026-04-${String((i % 28) + 1).padStart(2, '0')}`, 1300));
+ assert.strictEqual(countHistoryRows(h), 41 * 1300);
+ const pruned = applyHistoryRetention(h, '1000', Date.parse('2026-06-01'));
+ assert.strictEqual(pruned.length, 1);
+ assert.strictEqual(countHistoryRows(pruned), 1300);
+});
+
+test('empty history is returned as-is for any policy', () => {
+ assert.deepStrictEqual(applyHistoryRetention([], '7d', Date.now()), []);
+ assert.deepStrictEqual(applyHistoryRetention([], '100', Date.now()), []);
+});
diff --git a/tests/hosters.test.js b/tests/hosters.test.js
new file mode 100644
index 0000000..9f41eef
--- /dev/null
+++ b/tests/hosters.test.js
@@ -0,0 +1,95 @@
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+
+const { __test } = require('../lib/hosters');
+
+describe('hosters helpers', () => {
+ it('extracts VOE file_code from nested result payloads', () => {
+ assert.deepEqual(__test.parseVoeResult({ result: { file: { file_code: 'abc123' } } }), {
+ download_url: 'https://voe.sx/abc123',
+ embed_url: 'https://voe.sx/e/abc123',
+ file_code: 'abc123'
+ });
+ });
+
+ it('extracts VOE file_code from flat fallback payloads', () => {
+ assert.deepEqual(__test.parseVoeResult({ file_code: 'xyz789' }), {
+ download_url: 'https://voe.sx/xyz789',
+ embed_url: 'https://voe.sx/e/xyz789',
+ file_code: 'xyz789'
+ });
+ });
+
+ it('extracts upload server URLs from nested API responses', () => {
+ const url = __test.extractUploadServerUrl({
+ result: {
+ server: {
+ upload_url: 'https://delivery-hydra.voe-network.net/upload/01'
+ }
+ }
+ }, 'https://voe.sx');
+
+ assert.equal(url, 'https://delivery-hydra.voe-network.net/upload/01');
+ });
+
+ it('parseDoodstreamResult tolerates null/non-object payload without throwing', () => {
+ // Direct callers may bypass uploadFile's normalisation. The parser must
+ // never throw on bad input — empty fields are the contract.
+ for (const bad of [null, undefined, 'string', 42, true]) {
+ const r = __test.parseDoodstreamResult(bad);
+ assert.equal(r.file_code, null);
+ assert.equal(r.download_url, null);
+ assert.equal(r.embed_url, null);
+ }
+ });
+
+ it('parseDoodstreamResult handles result-as-array and result-as-object', () => {
+ const arr = __test.parseDoodstreamResult({ result: [{ filecode: 'AB1', protected_dl: 'https://x/1', protected_embed: 'https://x/e/1' }] });
+ assert.equal(arr.file_code, 'AB1');
+ assert.equal(arr.download_url, 'https://x/1');
+ assert.equal(arr.embed_url, 'https://x/e/1');
+
+ const obj = __test.parseDoodstreamResult({ result: { filecode: 'OBJ1', download_url: 'https://x/2' } });
+ assert.equal(obj.file_code, 'OBJ1');
+ assert.equal(obj.download_url, 'https://x/2');
+ });
+
+ it('parseByseResult tolerates null/non-object payload without throwing', () => {
+ for (const bad of [null, undefined, 'string', 42, []]) {
+ const r = __test.parseByseResult(bad);
+ assert.equal(r.file_code, null);
+ assert.equal(r.download_url, null);
+ assert.equal(r.embed_url, null);
+ }
+ });
+
+ it('parseByseResult handles malformed files entries (null, missing fields)', () => {
+ // Files array with a null first element (server returned [null])
+ const a = __test.parseByseResult({ files: [null] });
+ assert.equal(a.file_code, null);
+ // Files array with object missing both filecode and status
+ const b = __test.parseByseResult({ files: [{}] });
+ assert.equal(b.file_code, null);
+ });
+
+ it('parseByseResult throws fileRejected for non-OK status with empty filecode', () => {
+ assert.throws(
+ () => __test.parseByseResult({ files: [{ status: 'Not video file format' }] }),
+ (err) => err.fileRejected === true && /Not video file format/i.test(err.message)
+ );
+ });
+
+ it('parseByseResult flips to accountError for storage-exhausted phrasing', () => {
+ assert.throws(
+ () => __test.parseByseResult({ files: [{ status: 'not enough disk space on your account' }] }),
+ (err) => err.accountError === true
+ );
+ });
+
+ it('parseByseResult succeeds with valid filecode in files[0]', () => {
+ const r = __test.parseByseResult({ files: [{ filecode: 'GOOD123', status: 'OK' }] });
+ assert.equal(r.file_code, 'GOOD123');
+ assert.equal(r.download_url, 'https://byse.sx/d/GOOD123');
+ assert.equal(r.embed_url, 'https://byse.sx/e/GOOD123');
+ });
+});
diff --git a/tests/ip-allowlist.test.js b/tests/ip-allowlist.test.js
new file mode 100644
index 0000000..e0142fc
--- /dev/null
+++ b/tests/ip-allowlist.test.js
@@ -0,0 +1,52 @@
+const { test } = require('node:test');
+const assert = require('node:assert');
+const { normalizeIp, isLoopbackIp, matchIpRule, evaluateClientAllowed } = require('../lib/ip-allowlist');
+
+test('normalizeIp strips ::ffff: and lowercases', () => {
+ assert.equal(normalizeIp('::ffff:100.64.0.5'), '100.64.0.5');
+ assert.equal(normalizeIp('::FFFF:127.0.0.1'), '127.0.0.1');
+ assert.equal(normalizeIp(' 100.64.0.5 '), '100.64.0.5');
+});
+
+test('loopback is always allowed, even with a non-matching allowlist', () => {
+ for (const ip of ['127.0.0.1', '::1', '::ffff:127.0.0.1', '', 'localhost', '127.5.5.5']) {
+ assert.equal(evaluateClientAllowed(ip, ['203.0.113.5']), true, `${ip} loopback`);
+ }
+});
+
+test('fail-closed: empty allowlist rejects every non-loopback peer', () => {
+ for (const ip of ['100.64.0.5', '203.0.113.5', '10.0.0.2', '::ffff:192.168.1.9']) {
+ assert.equal(evaluateClientAllowed(ip, []), false, `${ip} must be rejected with empty allowlist`);
+ }
+});
+
+test('exact IP allow + reject', () => {
+ assert.equal(evaluateClientAllowed('203.0.113.5', ['203.0.113.5']), true);
+ assert.equal(evaluateClientAllowed('203.0.113.6', ['203.0.113.5']), false);
+});
+
+test('CIDR matching incl. the Tailscale CGNAT range 100.64.0.0/10', () => {
+ assert.equal(evaluateClientAllowed('100.64.0.5', ['100.64.0.0/10']), true);
+ assert.equal(evaluateClientAllowed('100.127.255.254', ['100.64.0.0/10']), true);
+ assert.equal(evaluateClientAllowed('100.128.0.1', ['100.64.0.0/10']), false, 'just outside the /10');
+ assert.equal(evaluateClientAllowed('::ffff:100.64.0.5', ['100.64.0.0/10']), true, 'mapped v4 in CIDR');
+ assert.equal(evaluateClientAllowed('10.0.0.5', ['10.0.0.0/24']), true);
+ assert.equal(evaluateClientAllowed('10.0.1.5', ['10.0.0.0/24']), false);
+});
+
+test('wildcard rules allow everything', () => {
+ assert.equal(evaluateClientAllowed('8.8.8.8', ['*']), true);
+ assert.equal(evaluateClientAllowed('8.8.8.8', ['0.0.0.0/0']), true);
+});
+
+test('matchIpRule rejects malformed rules and out-of-range octets', () => {
+ assert.equal(matchIpRule('1.2.3.4', 'not-an-ip'), false);
+ assert.equal(matchIpRule('1.2.3.4', '1.2.3.0/33'), false);
+ assert.equal(matchIpRule('1.2.3.999', '1.2.3.0/24'), false);
+});
+
+test('isLoopbackIp recognizes loopback forms', () => {
+ assert.equal(isLoopbackIp('127.0.0.1'), true);
+ assert.equal(isLoopbackIp('::1'), true);
+ assert.equal(isLoopbackIp('100.64.0.1'), false);
+});
diff --git a/tests/log-mode.test.js b/tests/log-mode.test.js
new file mode 100644
index 0000000..4becf1e
--- /dev/null
+++ b/tests/log-mode.test.js
@@ -0,0 +1,150 @@
+const { test } = require('node:test');
+const assert = require('node:assert');
+const { normalizeLogMode, resolveLogFileName, formatDateStamp, formatSessionStamp } = require('../lib/log-mode');
+
+// --- normalizeLogMode ---
+
+test('normalizeLogMode: default for empty/null/undefined is "single"', () => {
+ assert.equal(normalizeLogMode(), 'single');
+ assert.equal(normalizeLogMode(null), 'single');
+ assert.equal(normalizeLogMode({}), 'single');
+});
+
+test('normalizeLogMode: explicit logMode wins for all three valid values', () => {
+ assert.equal(normalizeLogMode({ logMode: 'single' }), 'single');
+ assert.equal(normalizeLogMode({ logMode: 'daily' }), 'daily');
+ assert.equal(normalizeLogMode({ logMode: 'session' }), 'session');
+});
+
+test('regression: legacy sessionLog:true maps to "daily", NOT "session"', () => {
+ // The legacy boolean field was named after a misnomer — it actually toggled
+ // per-day logging. Mapping it to "session" would silently flip every existing
+ // per-day user onto per-session, which is exactly the bug the migration trap
+ // exists to prevent.
+ assert.equal(normalizeLogMode({ sessionLog: true }), 'daily');
+});
+
+test('normalizeLogMode: sessionLog:false / missing maps to "single"', () => {
+ assert.equal(normalizeLogMode({ sessionLog: false }), 'single');
+});
+
+test('normalizeLogMode: explicit logMode beats the legacy sessionLog field', () => {
+ // Once a user picks a mode in 3.3.35+, the legacy boolean must NOT override.
+ assert.equal(normalizeLogMode({ logMode: 'session', sessionLog: true }), 'session');
+ assert.equal(normalizeLogMode({ logMode: 'single', sessionLog: true }), 'single');
+});
+
+test('normalizeLogMode: invalid logMode strings fall through to single (or legacy if present)', () => {
+ assert.equal(normalizeLogMode({ logMode: 'lolnope' }), 'single');
+ assert.equal(normalizeLogMode({ logMode: '' }), 'single');
+ assert.equal(normalizeLogMode({ logMode: 'lolnope', sessionLog: true }), 'daily');
+});
+
+// --- resolveLogFileName ---
+
+test('resolveLogFileName: single mode → bare basename + ext', () => {
+ assert.equal(
+ resolveLogFileName({ baseName: 'fileuploader', ext: '.log', mode: 'single' }),
+ 'fileuploader.log'
+ );
+});
+
+test('resolveLogFileName: daily mode → fileuploader-YYYY-MM-DD.log', () => {
+ const d = new Date(2026, 4, 28); // May 28, 2026 — month is 0-indexed
+ assert.equal(
+ resolveLogFileName({ baseName: 'fileuploader', ext: '.log', mode: 'daily', date: d }),
+ 'fileuploader-2026-05-28.log'
+ );
+});
+
+test('resolveLogFileName: session mode → .log (baseName ignored)', () => {
+ assert.equal(
+ resolveLogFileName({ baseName: 'fileuploader', ext: '.log', mode: 'session', sessionId: '26-05-2026-mdu-session-22-44' }),
+ '26-05-2026-mdu-session-22-44.log'
+ );
+});
+
+test('formatSessionStamp: DD-MM-YYYY-mdu-session-HH-MM', () => {
+ const { formatSessionStamp } = require('../lib/log-mode');
+ assert.equal(formatSessionStamp(new Date(2026, 5, 26, 6, 2, 36)), '26-06-2026-mdu-session-06-02');
+});
+
+test('formatSessionStamp: appends a 6-digit suffix when a rand is supplied', () => {
+ assert.equal(formatSessionStamp(new Date(2026, 5, 26, 6, 2, 36), '847581'), '26-06-2026-mdu-session-06-02-847581');
+ assert.equal(formatSessionStamp(new Date(2026, 5, 26, 6, 2, 36), 847581), '26-06-2026-mdu-session-06-02-847581');
+});
+
+test('resolveLogFileName: session mode with missing sessionId falls back to single (never emits malformed name)', () => {
+ assert.equal(
+ resolveLogFileName({ baseName: 'fileuploader', ext: '.log', mode: 'session' }),
+ 'fileuploader.log'
+ );
+});
+
+test('resolveLogFileName: unknown mode is treated as single', () => {
+ assert.equal(
+ resolveLogFileName({ baseName: 'fileuploader', ext: '.log', mode: 'lolnope' }),
+ 'fileuploader.log'
+ );
+});
+
+// --- stripModeStampFromFileName ---
+
+const { stripModeStampFromFileName } = require('../lib/log-mode');
+
+test('stripModeStampFromFileName: leaves bare names alone', () => {
+ assert.equal(stripModeStampFromFileName('fileuploader.log'), 'fileuploader.log');
+ assert.equal(stripModeStampFromFileName('fileuploader'), 'fileuploader');
+});
+
+test('stripModeStampFromFileName: strips a daily YYYY-MM-DD suffix', () => {
+ assert.equal(stripModeStampFromFileName('fileuploader-2026-06-03.log'), 'fileuploader.log');
+});
+
+test('stripModeStampFromFileName: strips a session-stamp suffix (with and without pid)', () => {
+ assert.equal(
+ stripModeStampFromFileName('fileuploader-session-2026-06-03_18-16-20-8132.log'),
+ 'fileuploader.log'
+ );
+ assert.equal(
+ stripModeStampFromFileName('fileuploader-session-2026-06-03_18-16-20.log'),
+ 'fileuploader.log'
+ );
+});
+
+test('stripModeStampFromFileName: new DD-MM-YYYY-mdu-session-HH-MM resets to the default base', () => {
+ assert.equal(stripModeStampFromFileName('26-06-2026-mdu-session-06-02.log'), 'fileuploader.log');
+ assert.equal(stripModeStampFromFileName('26-06-2026-mdu-session-06-02-847581.log'), 'fileuploader.log');
+});
+
+test('regression: resolveLogFileName(stripModeStampFromFileName(...)) is idempotent — persisting then re-resolving never compounds stamps', () => {
+ // This is the exact bug shape: persist the resolved path, then on next call
+ // re-resolve from the saved base — must produce the same file, not a doubled
+ // session-stamped one. The fix is the strip; this test guards against
+ // regressing _persistFallbackLogPath into the 3.3.35 bug.
+ const sessionId = '03-06-2026-mdu-session-18-16';
+ const dailyDate = new Date(2026, 5, 3);
+ for (const mode of ['daily', 'session']) {
+ const date = mode === 'daily' ? dailyDate : new Date();
+ const initial = resolveLogFileName({ baseName: 'fileuploader', ext: '.log', mode, date, sessionId });
+ const stripped = stripModeStampFromFileName(initial);
+ // After strip, the base should be back to the bare name.
+ assert.equal(stripped, 'fileuploader.log', `${mode}: strip should produce bare base`);
+ // Re-resolving from the bare base gives the same final filename — no doubling.
+ const reBase = stripped.replace(/\.log$/, '');
+ const second = resolveLogFileName({ baseName: reBase, ext: '.log', mode, date, sessionId });
+ assert.equal(second, initial, `${mode}: round-trip must be idempotent`);
+ }
+});
+
+// --- format helpers ---
+
+test('formatDateStamp: zero-pads month and day', () => {
+ assert.equal(formatDateStamp(new Date(2026, 0, 3)), '2026-01-03');
+ assert.equal(formatDateStamp(new Date(2026, 11, 31)), '2026-12-31');
+});
+
+test('formatSessionStamp: DD-MM-YYYY-mdu-session-HH-MM (no seconds/pid)', () => {
+ assert.equal(formatSessionStamp(new Date(2026, 4, 28, 7, 9, 5)), '28-05-2026-mdu-session-07-09');
+ assert.equal(formatSessionStamp(new Date(2026, 4, 28, 22, 44, 52)), '28-05-2026-mdu-session-22-44');
+});
diff --git a/tests/log-policy.test.js b/tests/log-policy.test.js
new file mode 100644
index 0000000..94e1e3e
--- /dev/null
+++ b/tests/log-policy.test.js
@@ -0,0 +1,52 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+
+const { hosterLogToFileEnabled } = require('../lib/log-policy');
+
+test('enabled by default when settings missing entirely', () => {
+ assert.equal(hosterLogToFileEnabled(null, 'voe.sx'), true);
+ assert.equal(hosterLogToFileEnabled(undefined, 'voe.sx'), true);
+ assert.equal(hosterLogToFileEnabled('not-an-object', 'voe.sx'), true);
+});
+
+test('enabled when hoster has no settings entry', () => {
+ assert.equal(hosterLogToFileEnabled({}, 'voe.sx'), true);
+ assert.equal(hosterLogToFileEnabled({ 'byse.sx': { logToFile: false } }, 'voe.sx'), true);
+});
+
+test('enabled when hoster entry has no logToFile key (back-compat with old configs)', () => {
+ assert.equal(hosterLogToFileEnabled({ 'voe.sx': { retries: 3 } }, 'voe.sx'), true);
+});
+
+test('enabled when logToFile is explicitly true', () => {
+ assert.equal(hosterLogToFileEnabled({ 'voe.sx': { logToFile: true } }, 'voe.sx'), true);
+});
+
+test('DISABLED only when logToFile is explicitly false', () => {
+ assert.equal(hosterLogToFileEnabled({ 'voe.sx': { logToFile: false } }, 'voe.sx'), false);
+});
+
+test('truthy-but-not-true values do not accidentally disable', () => {
+ // Only the strict boolean false disables — guards against e.g. a stored 0/""
+ assert.equal(hosterLogToFileEnabled({ 'voe.sx': { logToFile: 0 } }, 'voe.sx'), true);
+ assert.equal(hosterLogToFileEnabled({ 'voe.sx': { logToFile: '' } }, 'voe.sx'), true);
+ assert.equal(hosterLogToFileEnabled({ 'voe.sx': { logToFile: null } }, 'voe.sx'), true);
+ assert.equal(hosterLogToFileEnabled({ 'voe.sx': { logToFile: undefined } }, 'voe.sx'), true);
+});
+
+test('per-hoster independence: one off, others on', () => {
+ const settings = {
+ 'voe.sx': { logToFile: false },
+ 'byse.sx': { logToFile: true },
+ 'doodstream.com': { retries: 3 }
+ };
+ assert.equal(hosterLogToFileEnabled(settings, 'voe.sx'), false);
+ assert.equal(hosterLogToFileEnabled(settings, 'byse.sx'), true);
+ assert.equal(hosterLogToFileEnabled(settings, 'doodstream.com'), true);
+ assert.equal(hosterLogToFileEnabled(settings, 'clouddrop.cc'), true); // not present → on
+});
+
+test('malformed hoster entry (string/number) defaults to on', () => {
+ assert.equal(hosterLogToFileEnabled({ 'voe.sx': 'broken' }, 'voe.sx'), true);
+ assert.equal(hosterLogToFileEnabled({ 'voe.sx': 42 }, 'voe.sx'), true);
+});
diff --git a/tests/log-rotation.test.js b/tests/log-rotation.test.js
new file mode 100644
index 0000000..d17d3b8
--- /dev/null
+++ b/tests/log-rotation.test.js
@@ -0,0 +1,134 @@
+const { test, beforeEach, afterEach } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const { maybeRotateLogFile } = require('../lib/log-rotation');
+
+let tmpDir;
+let logFile;
+
+beforeEach(() => {
+ tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mhu-log-rotation-'));
+ logFile = path.join(tmpDir, 'fileuploader.log');
+});
+
+afterEach(() => {
+ try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch {}
+});
+
+function writeBytes(p, n, fill = 'a') {
+ fs.writeFileSync(p, fill.repeat(n), 'utf-8');
+}
+
+test('returns false and skips rotation when file does not exist', () => {
+ const result = maybeRotateLogFile(logFile, 100);
+ assert.equal(result, false);
+ assert.equal(fs.existsSync(logFile), false);
+});
+
+test('returns false when file is below the size cap', () => {
+ writeBytes(logFile, 50);
+ const result = maybeRotateLogFile(logFile, 100);
+ assert.equal(result, false);
+ assert.equal(fs.statSync(logFile).size, 50, 'live file untouched');
+ assert.equal(fs.existsSync(logFile + '.1'), false, 'no .1 created');
+});
+
+test('rotates live file to .1 when over cap', () => {
+ writeBytes(logFile, 200, 'X');
+ const result = maybeRotateLogFile(logFile, 100, 3);
+ assert.equal(result, true);
+ assert.equal(fs.existsSync(logFile), false, 'live file moved away');
+ const expectedBackup = path.join(tmpDir, 'fileuploader.1.log');
+ assert.equal(fs.existsSync(expectedBackup), true, '.1 backup exists');
+ assert.equal(fs.statSync(expectedBackup).size, 200);
+});
+
+test('shifts existing backups up: .1 → .2, .2 → .3 on rotation', () => {
+ writeBytes(path.join(tmpDir, 'fileuploader.2.log'), 10, 'B');
+ writeBytes(path.join(tmpDir, 'fileuploader.1.log'), 20, 'A');
+ writeBytes(logFile, 200, 'L');
+
+ const result = maybeRotateLogFile(logFile, 100, 3);
+ assert.equal(result, true);
+
+ // Live file → .1 (latest live data)
+ assert.equal(fs.statSync(path.join(tmpDir, 'fileuploader.1.log')).size, 200);
+ // Old .1 → .2
+ assert.equal(fs.statSync(path.join(tmpDir, 'fileuploader.2.log')).size, 20);
+ // Old .2 → .3
+ assert.equal(fs.statSync(path.join(tmpDir, 'fileuploader.3.log')).size, 10);
+});
+
+test('drops oldest backup when at maxBackups limit', () => {
+ // Pre-populate all three backup slots.
+ writeBytes(path.join(tmpDir, 'fileuploader.3.log'), 5, 'C'); // oldest, will be dropped
+ writeBytes(path.join(tmpDir, 'fileuploader.2.log'), 10, 'B');
+ writeBytes(path.join(tmpDir, 'fileuploader.1.log'), 20, 'A');
+ writeBytes(logFile, 200, 'L');
+
+ const result = maybeRotateLogFile(logFile, 100, 3);
+ assert.equal(result, true);
+
+ // Old .3 (5 bytes 'C') gone, replaced by old .2.
+ const f3 = fs.statSync(path.join(tmpDir, 'fileuploader.3.log'));
+ assert.equal(f3.size, 10, 'old .2 became new .3 (the C-file was dropped)');
+ // .2 = old .1
+ assert.equal(fs.statSync(path.join(tmpDir, 'fileuploader.2.log')).size, 20);
+ // .1 = the live file we just rotated
+ assert.equal(fs.statSync(path.join(tmpDir, 'fileuploader.1.log')).size, 200);
+});
+
+test('is idempotent — second call on still-large file rotates again', () => {
+ writeBytes(logFile, 200, 'X');
+ maybeRotateLogFile(logFile, 100, 3);
+ // Simulate fresh writes after the first rotation
+ writeBytes(logFile, 200, 'Y');
+ const result = maybeRotateLogFile(logFile, 100, 3);
+ assert.equal(result, true);
+ // The .Y file is now .1, the .X file moved to .2
+ assert.equal(fs.readFileSync(path.join(tmpDir, 'fileuploader.1.log'), 'utf-8')[0], 'Y');
+ assert.equal(fs.readFileSync(path.join(tmpDir, 'fileuploader.2.log'), 'utf-8')[0], 'X');
+});
+
+test('maxBackups=1: only keeps a single .1 backup, never .2', () => {
+ writeBytes(logFile, 200, 'L');
+ maybeRotateLogFile(logFile, 100, 1);
+ writeBytes(logFile, 200, 'M');
+ maybeRotateLogFile(logFile, 100, 1);
+
+ // .1 holds the latest rotated content (M)
+ assert.equal(fs.readFileSync(path.join(tmpDir, 'fileuploader.1.log'), 'utf-8')[0], 'M');
+ // .2 must NOT exist
+ assert.equal(fs.existsSync(path.join(tmpDir, 'fileuploader.2.log')), false);
+});
+
+test('invalid maxBytes (0, negative, NaN) is a no-op', () => {
+ writeBytes(logFile, 1000, 'X');
+ for (const max of [0, -1, NaN]) {
+ const r = maybeRotateLogFile(logFile, max);
+ assert.equal(r, false, `maxBytes=${max} should be no-op`);
+ }
+ assert.equal(fs.existsSync(logFile), true);
+ assert.equal(fs.existsSync(logFile + '.1'), false);
+});
+
+test('logs through provided debug callback on rotation', () => {
+ writeBytes(logFile, 200, 'X');
+ const messages = [];
+ maybeRotateLogFile(logFile, 100, 3, (m) => messages.push(m));
+ assert.ok(messages.length >= 1, 'at least one log message');
+ assert.ok(messages.some(m => m.includes('rotated')), `expected "rotated" in: ${messages.join(' | ')}`);
+});
+
+test('handles file without extension correctly', () => {
+ const noExtFile = path.join(tmpDir, 'plainlog');
+ writeBytes(noExtFile, 200, 'P');
+ const result = maybeRotateLogFile(noExtFile, 100, 3);
+ assert.equal(result, true);
+ // base = the full path, ext = '', so backup name is "plainlog.1"
+ assert.equal(fs.existsSync(path.join(tmpDir, 'plainlog.1')), true);
+ assert.equal(fs.existsSync(noExtFile), false);
+});
diff --git a/tests/online-backup-service.test.js b/tests/online-backup-service.test.js
new file mode 100644
index 0000000..88ede5b
--- /dev/null
+++ b/tests/online-backup-service.test.js
@@ -0,0 +1,71 @@
+const { once } = require('node:events');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { pathToFileURL } = require('node:url');
+const { after, before, describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+
+const {
+ createOnlineBackup,
+ deleteOnlineBackup,
+ downloadOnlineBackup,
+ uploadOnlineBackup
+} = require('../lib/online-backup');
+
+let rootDir;
+let server;
+let baseUrl;
+
+before(async () => {
+ rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mhu-backup-contract-'));
+ const moduleUrl = pathToFileURL(path.join(__dirname, '..', 'services', 'backup-api', 'src', 'server.mjs')).href;
+ const { createBackupServer } = await import(moduleUrl);
+ server = createBackupServer({ rootDir });
+ server.listen(0, '127.0.0.1');
+ await once(server, 'listening');
+ baseUrl = `http://127.0.0.1:${server.address().port}`;
+});
+
+after(async () => {
+ if (server) await new Promise((resolve) => server.close(resolve));
+ if (rootDir) fs.rmSync(rootDir, { recursive: true, force: true });
+});
+
+describe('online backup client and service contract', () => {
+ it('keeps older keys valid and stores ciphertext only', async () => {
+ const firstSettings = {
+ hosters: { 'byse.sx': [{ id: 'first', apiKey: 'first-secret' }] },
+ hosterSettings: { 'byse.sx': { retries: 3 } },
+ globalSettings: { alwaysOnTop: false },
+ history: []
+ };
+ const secondSettings = {
+ hosters: { 'byse.sx': [{ id: 'second', apiKey: 'second-secret' }] },
+ hosterSettings: { 'byse.sx': { retries: 7 } },
+ globalSettings: { alwaysOnTop: true },
+ history: []
+ };
+ const first = createOnlineBackup(firstSettings, '2.0.3');
+ const second = createOnlineBackup(secondSettings, '2.0.3');
+
+ await uploadOnlineBackup(first.record, baseUrl);
+ await uploadOnlineBackup(second.record, baseUrl);
+
+ assert.deepEqual((await downloadOnlineBackup(first.key, baseUrl)).settings, firstSettings);
+ assert.deepEqual((await downloadOnlineBackup(second.key, baseUrl)).settings, secondSettings);
+ const stored = fs.readdirSync(rootDir)
+ .filter((name) => name.endsWith('.json'))
+ .map((name) => fs.readFileSync(path.join(rootDir, name), 'utf8'))
+ .join('\n');
+ assert.equal(stored.includes('first-secret'), false);
+ assert.equal(stored.includes('second-secret'), false);
+ assert.equal(stored.includes(first.key), false);
+ assert.equal(stored.includes(second.key), false);
+
+ await deleteOnlineBackup(first.key, baseUrl);
+ await assert.rejects(downloadOnlineBackup(first.key, baseUrl), /nicht gefunden/i);
+ assert.deepEqual((await downloadOnlineBackup(second.key, baseUrl)).settings, secondSettings);
+ await deleteOnlineBackup(second.key, baseUrl);
+ });
+});
diff --git a/tests/online-backup.test.js b/tests/online-backup.test.js
new file mode 100644
index 0000000..44cc88d
--- /dev/null
+++ b/tests/online-backup.test.js
@@ -0,0 +1,165 @@
+const http = require('node:http');
+const { once } = require('node:events');
+const { afterEach, describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+
+const servers = [];
+
+afterEach(async () => {
+ await Promise.all(servers.splice(0).map((server) => new Promise((resolve) => server.close(resolve))));
+});
+
+function settings() {
+ return {
+ hosters: {
+ 'doodstream.com': [{ id: 'account-1', authType: 'api', apiKey: 'secret-api-key', enabled: true }]
+ },
+ hosterSettings: {
+ 'doodstream.com': { retries: 3, parallelCount: 5 }
+ },
+ globalSettings: {
+ alwaysOnTop: true,
+ webhookUrl: 'https://example.invalid/private-webhook'
+ },
+ history: []
+ };
+}
+
+describe('online backup key', () => {
+ it('creates a unique 75-character MHU key and restores every snapshot independently', () => {
+ const { createOnlineBackup, restoreOnlineBackup } = require('../lib/online-backup');
+ const first = createOnlineBackup(settings(), '2.0.3', '2026-08-09T00:00:00.000Z');
+ const secondSettings = settings();
+ secondSettings.globalSettings.alwaysOnTop = false;
+ const second = createOnlineBackup(secondSettings, '2.0.3', '2026-08-09T00:01:00.000Z');
+
+ assert.match(first.key, /^MHU2-[A-Za-z0-9_-]{70}$/);
+ assert.equal(first.key.length, 75);
+ assert.notEqual(second.key, first.key);
+ assert.deepEqual(restoreOnlineBackup(first.key, first.record.blob).settings, settings());
+ assert.equal(restoreOnlineBackup(second.key, second.record.blob).settings.globalSettings.alwaysOnTop, false);
+ });
+
+ it('never places credentials or the decryption secret in the server record', () => {
+ const { createOnlineBackup, parseOnlineBackupKey } = require('../lib/online-backup');
+ const created = createOnlineBackup(settings(), '2.0.3');
+ const serialized = JSON.stringify(created.record);
+ const parsed = parseOnlineBackupKey(created.key);
+
+ assert.equal(serialized.includes('secret-api-key'), false);
+ assert.equal(serialized.includes('private-webhook'), false);
+ assert.equal(serialized.includes(parsed.masterKey.toString('base64url')), false);
+ assert.deepEqual(Object.keys(created.record).sort(), ['blob', 'deleteVerifier', 'id']);
+ });
+
+ it('rejects corrupted keys, ciphertext and oversized settings', () => {
+ const { createOnlineBackup, parseOnlineBackupKey, restoreOnlineBackup } = require('../lib/online-backup');
+ const created = createOnlineBackup(settings(), '2.0.3');
+ const keyTail = created.key.endsWith('A') ? 'B' : 'A';
+ const blobTail = created.record.blob.endsWith('A') ? 'B' : 'A';
+
+ assert.throws(() => parseOnlineBackupKey(`${created.key.slice(0, -1)}${keyTail}`), /Schlüssel/i);
+ assert.throws(() => restoreOnlineBackup(created.key, `${created.record.blob.slice(0, -1)}${blobTail}`), /entschlüsselt|beschädigt/i);
+ assert.throws(() => createOnlineBackup({ huge: 'x'.repeat(600_000) }, '2.0.3'), /zu groß/i);
+ });
+});
+
+describe('online backup transport', () => {
+ it('uses only POST bodies and never sends the master key or record id in URLs', async () => {
+ const {
+ createOnlineBackup,
+ deleteOnlineBackup,
+ downloadOnlineBackup,
+ parseOnlineBackupKey,
+ uploadOnlineBackup
+ } = require('../lib/online-backup');
+ let stored = null;
+ let deleteRequest = null;
+ const requestedUrls = [];
+ const server = http.createServer(async (request, response) => {
+ requestedUrls.push(String(request.url || ''));
+ const chunks = [];
+ for await (const chunk of request) chunks.push(Buffer.from(chunk));
+ const body = chunks.length ? JSON.parse(Buffer.concat(chunks).toString('utf8')) : {};
+ if (request.method === 'POST' && request.url === '/v1/backups') {
+ stored = body;
+ response.writeHead(201, { 'content-type': 'application/json' });
+ response.end('{"created":true}');
+ return;
+ }
+ if (request.method === 'POST' && request.url === '/v1/backups/restore' && stored) {
+ assert.equal(body.id, stored.id);
+ response.writeHead(200, { 'content-type': 'application/json' });
+ response.end(JSON.stringify({ blob: stored.blob }));
+ return;
+ }
+ if (request.method === 'POST' && request.url === '/v1/backups/delete' && stored) {
+ deleteRequest = body;
+ response.writeHead(204);
+ response.end();
+ return;
+ }
+ response.writeHead(404, { 'content-type': 'application/json' });
+ response.end('{"error":"not_found"}');
+ });
+ servers.push(server);
+ server.listen(0, '127.0.0.1');
+ await once(server, 'listening');
+ const baseUrl = `http://127.0.0.1:${server.address().port}`;
+ const created = createOnlineBackup(settings(), '2.0.3');
+
+ await uploadOnlineBackup(created.record, baseUrl);
+ const restored = await downloadOnlineBackup(created.key, baseUrl);
+ await deleteOnlineBackup(created.key, baseUrl);
+
+ assert.deepEqual(restored.settings, settings());
+ assert.equal(JSON.stringify(stored).includes(parseOnlineBackupKey(created.key).masterKey.toString('base64url')), false);
+ assert.match(deleteRequest.deleteSecret, /^[A-Za-z0-9_-]{43}$/);
+ assert.deepEqual(requestedUrls, ['/v1/backups', '/v1/backups/restore', '/v1/backups/delete']);
+ assert.equal(requestedUrls.join(' ').includes(stored.id), false);
+ });
+
+ it('does not reflect server response bodies into client errors', async () => {
+ const { createOnlineBackup, uploadOnlineBackup } = require('../lib/online-backup');
+ const server = http.createServer((_request, response) => {
+ response.writeHead(500, { 'content-type': 'application/json' });
+ response.end('{"leaked":"server-secret-value"}');
+ });
+ servers.push(server);
+ server.listen(0, '127.0.0.1');
+ await once(server, 'listening');
+ const created = createOnlineBackup(settings(), '2.0.3');
+
+ await assert.rejects(
+ uploadOnlineBackup(created.record, `http://127.0.0.1:${server.address().port}`),
+ (error) => !String(error.message).includes('server-secret-value')
+ );
+ });
+
+ it('keeps the timeout active until the response body is fully read', async () => {
+ const { createOnlineBackup, downloadOnlineBackup } = require('../lib/online-backup');
+ const created = createOnlineBackup(settings(), '2.0.3');
+ const fetchImpl = async (_url, options) => ({
+ status: 200,
+ headers: new Headers({ 'content-type': 'application/json' }),
+ body: {
+ getReader: () => ({
+ read: () => new Promise((_resolve, reject) => {
+ options.signal.addEventListener('abort', () => reject(new Error('aborted')), { once: true });
+ }),
+ cancel: async () => {}
+ })
+ }
+ });
+
+ const outcome = await Promise.race([
+ assert.rejects(
+ downloadOnlineBackup(created.key, 'http://127.0.0.1:8788', { fetchImpl, timeoutMs: 20 }),
+ /antwortet nicht/i
+ ).then(() => 'timed-out'),
+ new Promise((resolve) => setTimeout(() => resolve('hung'), 120))
+ ]);
+
+ assert.equal(outcome, 'timed-out');
+ });
+});
diff --git a/tests/orphan-tmp.test.js b/tests/orphan-tmp.test.js
new file mode 100644
index 0000000..f639565
--- /dev/null
+++ b/tests/orphan-tmp.test.js
@@ -0,0 +1,56 @@
+const { test } = require('node:test');
+const assert = require('node:assert');
+const { selectOrphanTmps } = require('../lib/orphan-tmp');
+
+const BASE = 'electron-config.json';
+const aliveSet = new Set([100, 200]);
+const isAlive = (pid) => aliveSet.has(pid);
+
+test('selects only dead-pid ..tmp orphans', () => {
+ const files = [
+ 'electron-config.json',
+ 'electron-config.json.bak',
+ 'electron-config.json.tmp',
+ 'electron-config.json.100.tmp',
+ 'electron-config.json.200.tmp',
+ 'electron-config.json.999.tmp',
+ 'electron-config.json.4242.tmp',
+ 'something-else.500.tmp',
+ 'electron-config.json.abc.tmp'
+ ];
+ const orphans = selectOrphanTmps(files, { baseName: BASE, currentPid: 7, isAlive });
+ assert.deepEqual(orphans.sort(), ['electron-config.json.4242.tmp', 'electron-config.json.999.tmp']);
+});
+
+test('never selects the current process tmp', () => {
+ const files = ['electron-config.json.7.tmp'];
+ assert.deepEqual(selectOrphanTmps(files, { baseName: BASE, currentPid: 7, isAlive: () => false }), []);
+});
+
+test('never selects the FIXED .tmp (used by async _atomicWrite)', () => {
+ const files = ['electron-config.json.tmp'];
+ assert.deepEqual(selectOrphanTmps(files, { baseName: BASE, currentPid: 7, isAlive: () => false }), []);
+});
+
+test('never selects the live config or its .bak', () => {
+ const files = ['electron-config.json', 'electron-config.json.bak'];
+ assert.deepEqual(selectOrphanTmps(files, { baseName: BASE, currentPid: 7, isAlive: () => false }), []);
+});
+
+test('alive pid (incl. EPERM-as-alive) is skipped, preventing deletion of a concurrent instance tmp', () => {
+ const files = ['electron-config.json.100.tmp', 'electron-config.json.300.tmp'];
+ const orphans = selectOrphanTmps(files, { baseName: BASE, currentPid: 7, isAlive: (p) => p === 100 });
+ assert.deepEqual(orphans, ['electron-config.json.300.tmp']);
+});
+
+test('robust to junk / missing inputs', () => {
+ assert.deepEqual(selectOrphanTmps(null, { baseName: BASE, currentPid: 1, isAlive }), []);
+ assert.deepEqual(selectOrphanTmps(['x', 42, null, undefined], { baseName: BASE, currentPid: 1, isAlive }), []);
+ assert.deepEqual(selectOrphanTmps(['electron-config.json.5.tmp'], {}), []);
+ assert.deepEqual(selectOrphanTmps(['electron-config.json.5.tmp'], { baseName: '', currentPid: 1, isAlive }), []);
+});
+
+test('does not match a different base that shares a prefix', () => {
+ const files = ['electron-config.json.backup.5.tmp'];
+ assert.deepEqual(selectOrphanTmps(files, { baseName: BASE, currentPid: 7, isAlive: () => false }), []);
+});
diff --git a/tests/package-build-files.test.js b/tests/package-build-files.test.js
new file mode 100644
index 0000000..b801e3e
--- /dev/null
+++ b/tests/package-build-files.test.js
@@ -0,0 +1,55 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const Module = require('node:module');
+const packageJson = require('../package.json');
+
+test('packages every Electron preload referenced by the main process', () => {
+ assert.ok(packageJson.build.files.includes('preload.js'));
+ assert.ok(packageJson.build.files.includes('preload-drop-target.js'));
+});
+
+test('close readiness is signaled only after the renderer explicitly finishes initialization', () => {
+ const listeners = new Map();
+ const sent = [];
+ let exposedApi = null;
+ const electronMock = {
+ contextBridge: {
+ exposeInMainWorld: (_name, api) => { exposedApi = api; }
+ },
+ ipcRenderer: {
+ invoke: () => Promise.resolve(),
+ on: (channel, listener) => { listeners.set(channel, listener); },
+ send: (...args) => { sent.push(args); },
+ removeAllListeners: () => {}
+ },
+ webUtils: {
+ getPathForFile: () => ''
+ }
+ };
+ const originalLoad = Module._load;
+ const preloadPath = require.resolve('../preload');
+ delete require.cache[preloadPath];
+ Module._load = function (request, parent, isMain) {
+ if (request === 'electron') return electronMock;
+ return originalLoad.call(this, request, parent, isMain);
+ };
+ try {
+ require(preloadPath);
+ } finally {
+ Module._load = originalLoad;
+ }
+
+ let closeAttempt = null;
+ exposedApi.onPrepareClose(attempt => { closeAttempt = attempt; });
+ assert.deepEqual(sent, []);
+
+ listeners.get('app:prepare-close')({}, 7);
+ assert.equal(closeAttempt, 7);
+ assert.deepEqual(sent, [['app:close-preparation-started', 7]]);
+
+ exposedApi.signalCloseHandshakeReady();
+ assert.deepEqual(sent, [
+ ['app:close-preparation-started', 7],
+ ['app:close-handshake-ready']
+ ]);
+});
diff --git a/tests/public-release-verifier.test.js b/tests/public-release-verifier.test.js
new file mode 100644
index 0000000..091e67e
--- /dev/null
+++ b/tests/public-release-verifier.test.js
@@ -0,0 +1,75 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const root = path.resolve(__dirname, '..');
+const rootFiles = [
+ '.gitignore',
+ 'README.md',
+ 'SECURITY.md',
+ 'eslint.config.mjs',
+ 'main.js',
+ 'package-lock.json',
+ 'package.json',
+ 'preload-drop-target.js',
+ 'preload.js'
+];
+const directoryRoots = ['assets', 'lib', 'renderer', 'services/backup-api', 'tests'];
+const scriptFiles = ['scripts/afterPack.cjs', 'scripts/release-plan.mjs', 'scripts/verify-public-release.mjs'];
+
+function copyDirectory(source, destination) {
+ fs.mkdirSync(destination, { recursive: true });
+ for (const entry of fs.readdirSync(source, { withFileTypes: true })) {
+ if (/^_ui-inject\..+\.tmp\.js$/.test(entry.name)) continue;
+ const sourcePath = path.join(source, entry.name);
+ const destinationPath = path.join(destination, entry.name);
+ if (entry.isDirectory()) copyDirectory(sourcePath, destinationPath);
+ else if (entry.isFile()) fs.copyFileSync(sourcePath, destinationPath);
+ }
+}
+
+function createStage() {
+ const stage = fs.mkdtempSync(path.join(os.tmpdir(), 'mhu-public-verifier-'));
+ for (const relativePath of rootFiles) {
+ const destination = path.join(stage, relativePath);
+ fs.mkdirSync(path.dirname(destination), { recursive: true });
+ fs.copyFileSync(path.join(root, relativePath), destination);
+ }
+ for (const relativePath of directoryRoots) copyDirectory(path.join(root, relativePath), path.join(stage, relativePath));
+ for (const relativePath of scriptFiles) {
+ const destination = path.join(stage, relativePath);
+ fs.mkdirSync(path.dirname(destination), { recursive: true });
+ fs.copyFileSync(path.join(root, relativePath), destination);
+ }
+ fs.rmSync(path.join(stage, 'assets', 'product-overview.png'), { force: true });
+ return stage;
+}
+
+function verify(stage, version = '2.0.6') {
+ return spawnSync(process.execPath, ['scripts/verify-public-release.mjs', '--source-only', '--version', version], {
+ cwd: stage,
+ encoding: 'utf8'
+ });
+}
+
+test('public release verifier accepts only the exact source manifest and target version', (t) => {
+ const stage = createStage();
+ t.after(() => fs.rmSync(stage, { recursive: true, force: true }));
+
+ const baseline = verify(stage);
+ assert.equal(baseline.status, 0, baseline.stderr);
+ assert.match(baseline.stdout, /layout=exact/);
+
+ fs.writeFileSync(path.join(stage, 'tests', 'unexpected.json'), '{}');
+ const extra = verify(stage);
+ assert.equal(extra.status, 1);
+ assert.match(extra.stderr, /tests\/unexpected\.json\tsource-layout-allowlist/);
+ fs.rmSync(path.join(stage, 'tests', 'unexpected.json'));
+
+ const wrongVersion = verify(stage, '2.0.5');
+ assert.equal(wrongVersion.status, 1);
+ assert.match(wrongVersion.stderr, /package\.json\tpackage-version-target/);
+});
diff --git a/tests/queue-dedup-property.test.js b/tests/queue-dedup-property.test.js
new file mode 100644
index 0000000..9d4c0a7
--- /dev/null
+++ b/tests/queue-dedup-property.test.js
@@ -0,0 +1,114 @@
+const { test } = require('node:test');
+const assert = require('node:assert');
+const { partitionRestoredJobsByLog } = require('../lib/queue-dedup');
+
+function lcg(seed) {
+ let s = seed >>> 0;
+ return () => { s = (Math.imul(s, 1664525) + 1013904223) >>> 0; return s / 4294967296; };
+}
+
+function key(f, h) { return `${String(f).toLowerCase()}|${String(h).toLowerCase()}`; }
+
+test('property: removed iff (done && key in log) OR (savedAt finite && key unambiguous && newest matching log ts >= floor(savedAt/1000)*1000)', () => {
+ const rnd = lcg(0x9e3779b1);
+ const statuses = ['preview', 'done', 'error', 'aborted', 'queued', 'skipped'];
+ const hosters = ['voe.sx', 'byse.sx', 'doodstream.com'];
+ const names = ['a.mkv', 'b.mp4', 'A.MKV', 'c.mov'];
+ const folders = ['C:/A/', 'C:/B/', 'D:/down/'];
+ const pick = (arr) => arr[Math.floor(rnd() * arr.length)];
+
+ for (let iter = 0; iter < 3000; iter++) {
+ const useSavedAt = rnd() < 0.7;
+ const savedAt = useSavedAt ? Math.floor(rnd() * 2_000_000_000_000) : undefined;
+
+ const jobs = [];
+ const nJobs = 1 + Math.floor(rnd() * 6);
+ for (let i = 0; i < nJobs; i++) {
+ const name = pick(names);
+ // Mix shared and distinct paths so ambiguous keys (same name+hoster,
+ // different folder) actually occur and exercise the guard.
+ jobs.push({ id: `j${i}`, fileName: name, hoster: pick(hosters), status: pick(statuses), file: `${pick(folders)}${name}` });
+ }
+
+ const log = [];
+ const nLog = Math.floor(rnd() * 5);
+ for (let i = 0; i < nLog; i++) {
+ const hasTs = rnd() < 0.8;
+ log.push({ fileName: pick(names), hoster: pick(hosters), ts: hasTs ? Math.floor(rnd() * 2_000_000_000_000) : undefined });
+ }
+
+ const logKeys = new Set();
+ const maxTs = new Map();
+ for (const e of log) {
+ const k = key(e.fileName, e.hoster);
+ logKeys.add(k);
+ if (typeof e.ts === 'number' && isFinite(e.ts)) {
+ const prev = maxTs.get(k);
+ if (prev === undefined || e.ts > prev) maxTs.set(k, e.ts);
+ }
+ }
+ const filesPerKey = new Map();
+ for (const job of jobs) {
+ const k = key(job.fileName, job.hoster);
+ if (!filesPerKey.has(k)) filesPerKey.set(k, new Set());
+ filesPerKey.get(k).add(job.file || '');
+ }
+ const floor = (typeof savedAt === 'number' && isFinite(savedAt)) ? Math.floor(savedAt / 1000) * 1000 : null;
+
+ const { kept, removed } = partitionRestoredJobsByLog(jobs, log, savedAt);
+
+ assert.equal(kept.length + removed.length, jobs.length, `iter ${iter}: partition must cover every job exactly once`);
+ const keptIds = new Set(kept.map(j => j.id));
+ const removedIds = new Set(removed.map(j => j.id));
+ assert.equal(keptIds.size + removedIds.size, jobs.length, `iter ${iter}: no job in both partitions`);
+
+ for (const job of jobs) {
+ const k = key(job.fileName, job.hoster);
+ const doneInLog = job.status === 'done' && logKeys.has(k);
+ const unambiguous = filesPerKey.get(k).size <= 1;
+ const afterSnap = floor !== null && unambiguous && maxTs.has(k) && maxTs.get(k) >= floor;
+ const shouldRemove = doneInLog || afterSnap;
+ assert.equal(removedIds.has(job.id), shouldRemove,
+ `iter ${iter}: job ${job.id} (status=${job.status} key=${k} unambig=${unambiguous}) expected removed=${shouldRemove}`);
+ }
+ }
+});
+
+test('property: a genuinely-pending job is NEVER lost to a same-basename sibling completing after the snapshot', () => {
+ const rnd = lcg(0x1234abcd);
+ for (let iter = 0; iter < 500; iter++) {
+ const savedAt = 1_000_000_000_000 + Math.floor(rnd() * 1_000_000);
+ // X completed after the snapshot (logged); Y is a DIFFERENT file, same
+ // basename + hoster, genuinely pending. Y must survive.
+ const jobs = [
+ { id: 'X', fileName: 'clip.mp4', hoster: 'voe.sx', status: 'preview', file: 'C:/A/clip.mp4' },
+ { id: 'Y', fileName: 'clip.mp4', hoster: 'voe.sx', status: 'preview', file: 'C:/B/clip.mp4' }
+ ];
+ const log = [{ fileName: 'clip.mp4', hoster: 'voe.sx', ts: savedAt + 1000 + Math.floor(rnd() * 1000) }];
+ const { kept } = partitionRestoredJobsByLog(jobs, log, savedAt);
+ assert.ok(kept.some(j => j.id === 'Y'), `iter ${iter}: pending Y must never be silently dropped`);
+ }
+});
+
+test('property: 2-arg legacy call NEVER removes a non-done job (the v3.3.80 canary, fuzzed)', () => {
+ const rnd = lcg(0xdeadbeef);
+ const statuses = ['preview', 'error', 'aborted', 'queued', 'skipped'];
+ const hosters = ['voe.sx', 'byse.sx'];
+ const names = ['a.mkv', 'b.mp4'];
+ const pick = (arr) => arr[Math.floor(rnd() * arr.length)];
+
+ for (let iter = 0; iter < 1000; iter++) {
+ const jobs = [];
+ const nJobs = 1 + Math.floor(rnd() * 5);
+ for (let i = 0; i < nJobs; i++) {
+ jobs.push({ id: `j${i}`, fileName: pick(names), hoster: pick(hosters), status: pick(statuses), file: `C:/x/${i}` });
+ }
+ const log = [];
+ const nLog = Math.floor(rnd() * 4);
+ for (let i = 0; i < nLog; i++) {
+ log.push({ fileName: pick(names), hoster: pick(hosters), ts: Math.floor(rnd() * 2_000_000_000_000) });
+ }
+ const { removed } = partitionRestoredJobsByLog(jobs, log);
+ assert.ok(removed.every(j => j.status === 'done'), `iter ${iter}: legacy 2-arg call must never drop a non-done job`);
+ }
+});
diff --git a/tests/queue-dedup.test.js b/tests/queue-dedup.test.js
new file mode 100644
index 0000000..c567d5b
--- /dev/null
+++ b/tests/queue-dedup.test.js
@@ -0,0 +1,253 @@
+const { test } = require('node:test');
+const assert = require('node:assert');
+const { partitionRestoredJobsByLog, completedSelectionKeys } = require('../lib/queue-dedup');
+
+function job(status, fileName, hoster) {
+ return { status, fileName, hoster, file: `C:/dl/${fileName}` };
+}
+
+test('regression: pending preview jobs are NEVER dropped, even when all match the log', () => {
+ // Exact shape of the reproduced bug: 4 preview jobs for one file across 4
+ // hosters, every fileName|hoster present in the lifetime upload log.
+ const jobs = [
+ job('preview', 'Einfach mal die Fresse halten!!!.mp4', 'doodstream.com'),
+ job('preview', 'Einfach mal die Fresse halten!!!.mp4', 'voe.sx'),
+ job('preview', 'Einfach mal die Fresse halten!!!.mp4', 'vidmoly.me'),
+ job('preview', 'Einfach mal die Fresse halten!!!.mp4', 'byse.sx')
+ ];
+ const log = [
+ { fileName: 'Einfach mal die Fresse halten!!!.mp4', hoster: 'doodstream.com' },
+ { fileName: 'Einfach mal die Fresse halten!!!.mp4', hoster: 'voe.sx' },
+ { fileName: 'Einfach mal die Fresse halten!!!.mp4', hoster: 'vidmoly.me' },
+ { fileName: 'Einfach mal die Fresse halten!!!.mp4', hoster: 'byse.sx' }
+ ];
+ const { kept, removed } = partitionRestoredJobsByLog(jobs, log);
+ assert.equal(removed.length, 0, 'no pending job may be removed');
+ assert.equal(kept.length, 4, 'all 4 pending jobs survive restart/update');
+});
+
+test('done jobs in the log are dropped (declutter); pending/error/aborted kept', () => {
+ const jobs = [
+ job('done', 'a.mkv', 'doodstream.com'),
+ job('preview', 'a.mkv', 'voe.sx'),
+ job('error', 'b.mkv', 'doodstream.com'),
+ job('aborted', 'c.mkv', 'doodstream.com')
+ ];
+ const log = [
+ { fileName: 'a.mkv', hoster: 'doodstream.com' },
+ { fileName: 'a.mkv', hoster: 'voe.sx' },
+ { fileName: 'b.mkv', hoster: 'doodstream.com' },
+ { fileName: 'c.mkv', hoster: 'doodstream.com' }
+ ];
+ const { kept, removed } = partitionRestoredJobsByLog(jobs, log);
+ assert.equal(removed.length, 1);
+ assert.equal(removed[0].status, 'done');
+ assert.equal(removed[0].hoster, 'doodstream.com');
+ // The preview a.mkv|voe.sx, error b.mkv, aborted c.mkv all survive.
+ assert.equal(kept.length, 3);
+ assert.ok(kept.some(j => j.status === 'preview' && j.hoster === 'voe.sx'));
+ assert.ok(kept.some(j => j.status === 'error'));
+ assert.ok(kept.some(j => j.status === 'aborted'));
+});
+
+test('done job NOT in the log is kept (e.g. hoster had logToFile disabled)', () => {
+ const jobs = [job('done', 'd.mkv', 'doodstream.com')];
+ const { kept, removed } = partitionRestoredJobsByLog(jobs, []);
+ assert.equal(removed.length, 0);
+ assert.equal(kept.length, 1);
+});
+
+test('case-insensitive match on fileName and hoster', () => {
+ const jobs = [job('done', 'Movie.MKV', 'DoodStream.com')];
+ const log = [{ fileName: 'movie.mkv', hoster: 'doodstream.com' }];
+ const { removed } = partitionRestoredJobsByLog(jobs, log);
+ assert.equal(removed.length, 1);
+});
+
+test('empty/missing inputs do not throw', () => {
+ assert.deepEqual(partitionRestoredJobsByLog([], []), { kept: [], removed: [] });
+ assert.deepEqual(partitionRestoredJobsByLog(null, null), { kept: [], removed: [] });
+ const jobs = [job('done', 'x.mkv', 'voe.sx')];
+ assert.equal(partitionRestoredJobsByLog(jobs, undefined).kept.length, 1);
+});
+
+const T = (s) => Date.parse(s.replace(' ', 'T'));
+
+test('ts-gate: preview job uploaded AFTER the snapshot is dropped (the ghost bug)', () => {
+ const jobs = [job('preview', 'a.mkv', 'voe.sx')];
+ const log = [{ fileName: 'a.mkv', hoster: 'voe.sx', ts: T('2026-06-19 12:00:05') }];
+ const savedAt = T('2026-06-19 12:00:00');
+ const { kept, removed } = partitionRestoredJobsByLog(jobs, log, savedAt);
+ assert.equal(removed.length, 1, 'completed-after-snapshot preview is a ghost → drop');
+ assert.equal(kept.length, 0);
+});
+
+test('ts-gate: preview job whose only log entry PREDATES the snapshot is kept (intentional re-upload)', () => {
+ const jobs = [job('preview', 'a.mkv', 'voe.sx')];
+ const log = [{ fileName: 'a.mkv', hoster: 'voe.sx', ts: T('2026-06-19 11:00:00') }];
+ const savedAt = T('2026-06-19 12:00:00');
+ const { kept, removed } = partitionRestoredJobsByLog(jobs, log, savedAt);
+ assert.equal(removed.length, 0, 'old upload + freshly-queued re-upload must survive');
+ assert.equal(kept.length, 1);
+});
+
+test('ts-gate: same-second completion is dropped (savedAt floored to the second)', () => {
+ const jobs = [job('preview', 'a.mkv', 'voe.sx')];
+ const log = [{ fileName: 'a.mkv', hoster: 'voe.sx', ts: T('2026-06-19 12:00:00') }];
+ const savedAt = T('2026-06-19 12:00:00') + 800;
+ const { removed } = partitionRestoredJobsByLog(jobs, log, savedAt);
+ assert.equal(removed.length, 1, 'log second-granularity must not let same-second ghosts slip through');
+});
+
+test('ts-gate: uses the MAX log ts per key (re-upload after a stale earlier entry)', () => {
+ const jobs = [job('preview', 'a.mkv', 'voe.sx')];
+ const log = [
+ { fileName: 'a.mkv', hoster: 'voe.sx', ts: T('2026-06-19 11:00:00') },
+ { fileName: 'a.mkv', hoster: 'voe.sx', ts: T('2026-06-19 12:00:05') }
+ ];
+ const savedAt = T('2026-06-19 12:00:00');
+ const { removed } = partitionRestoredJobsByLog(jobs, log, savedAt);
+ assert.equal(removed.length, 1, 'newest matching log entry decides');
+});
+
+test('ts-gate inactive without savedAt → legacy behavior (preview kept even if ts newer)', () => {
+ const jobs = [job('preview', 'a.mkv', 'voe.sx')];
+ const log = [{ fileName: 'a.mkv', hoster: 'voe.sx', ts: T('2026-06-19 12:00:05') }];
+ const { kept, removed } = partitionRestoredJobsByLog(jobs, log);
+ assert.equal(removed.length, 0);
+ assert.equal(kept.length, 1);
+});
+
+test('ts-gate inactive when log entry lacks ts → legacy behavior', () => {
+ const jobs = [job('preview', 'a.mkv', 'voe.sx')];
+ const log = [{ fileName: 'a.mkv', hoster: 'voe.sx' }];
+ const savedAt = T('2026-06-19 12:00:00');
+ const { kept, removed } = partitionRestoredJobsByLog(jobs, log, savedAt);
+ assert.equal(removed.length, 0);
+ assert.equal(kept.length, 1);
+});
+
+test('ts-gate: done job uploaded after snapshot is dropped via either rule', () => {
+ const jobs = [job('done', 'a.mkv', 'voe.sx')];
+ const log = [{ fileName: 'a.mkv', hoster: 'voe.sx', ts: T('2026-06-19 12:00:05') }];
+ const savedAt = T('2026-06-19 12:00:00');
+ const { removed } = partitionRestoredJobsByLog(jobs, log, savedAt);
+ assert.equal(removed.length, 1);
+});
+
+test('ts-gate ambiguity guard: a pending same-basename file in a DIFFERENT folder is NOT lost when a sibling completes after the snapshot', () => {
+ // X (C:/A/clip.mp4) was uploaded after the snapshot and logged. Y is a
+ // genuinely-different file (C:/B/clip.mp4), same basename + hoster, still
+ // pending. The log records only basenames, so the ts-rule must not drop Y.
+ const jobs = [
+ { status: 'preview', fileName: 'clip.mp4', hoster: 'voe.sx', file: 'C:/A/clip.mp4' },
+ { status: 'preview', fileName: 'clip.mp4', hoster: 'voe.sx', file: 'C:/B/clip.mp4' }
+ ];
+ const savedAt = T('2026-06-19 12:00:00');
+ const log = [{ fileName: 'clip.mp4', hoster: 'voe.sx', ts: T('2026-06-19 12:00:05') }];
+ const { kept, removed } = partitionRestoredJobsByLog(jobs, log, savedAt);
+ assert.equal(removed.length, 0, 'ambiguous key -> ts-rule suppressed, no pending file lost');
+ assert.equal(kept.length, 2);
+});
+
+test('ts-gate ambiguity guard: the done-in-log rule still applies on an ambiguous key', () => {
+ // Even when the key is ambiguous, a job that is actually 'done' and in the log
+ // is still decluttered (pre-existing rule, unchanged by the guard).
+ const jobs = [
+ { status: 'done', fileName: 'clip.mp4', hoster: 'voe.sx', file: 'C:/A/clip.mp4' },
+ { status: 'preview', fileName: 'clip.mp4', hoster: 'voe.sx', file: 'C:/B/clip.mp4' }
+ ];
+ const log = [{ fileName: 'clip.mp4', hoster: 'voe.sx', ts: T('2026-06-19 12:00:05') }];
+ const savedAt = T('2026-06-19 12:00:00');
+ const { kept, removed } = partitionRestoredJobsByLog(jobs, log, savedAt);
+ assert.equal(removed.length, 1);
+ assert.equal(removed[0].status, 'done');
+ assert.equal(removed[0].file, 'C:/A/clip.mp4');
+ assert.ok(kept.some(j => j.file === 'C:/B/clip.mp4'), 'the distinct pending file survives');
+});
+
+test('ts-gate: a unique-path ghost still drops (guard does not weaken the common case)', () => {
+ const jobs = [{ status: 'preview', fileName: 'clip.mp4', hoster: 'voe.sx', file: 'C:/A/clip.mp4' }];
+ const log = [{ fileName: 'clip.mp4', hoster: 'voe.sx', ts: T('2026-06-19 12:00:05') }];
+ const savedAt = T('2026-06-19 12:00:00');
+ const { removed } = partitionRestoredJobsByLog(jobs, log, savedAt);
+ assert.equal(removed.length, 1, 'single job for the key -> unambiguous -> ghost dropped as before');
+});
+
+test('ts-gate: multi-hoster partial completion — the reported bug shape (drop only the completed hosters)', () => {
+ // One file queued to 4 hosters; close mid-upload. After the snapshot, 2 hosters
+ // completed (logged), 2 never started. On restart all 4 restore as 'preview'.
+ // Must drop EXACTLY the 2 that completed and keep the 2 still-pending. This also
+ // pins per-hoster keying: a fileName-only gate would wrongly drop all 4.
+ const f = 'Einfach mal die Fresse halten!!!.mp4';
+ const jobs = [
+ job('preview', f, 'doodstream.com'),
+ job('preview', f, 'voe.sx'),
+ job('preview', f, 'vidmoly.me'),
+ job('preview', f, 'byse.sx')
+ ];
+ const savedAt = T('2026-06-19 12:00:00');
+ const log = [
+ { fileName: f, hoster: 'doodstream.com', ts: T('2026-06-19 12:00:08') },
+ { fileName: f, hoster: 'voe.sx', ts: T('2026-06-19 12:00:11') }
+ ];
+ const { kept, removed } = partitionRestoredJobsByLog(jobs, log, savedAt);
+ assert.equal(removed.length, 2, 'only the 2 completed-after-snapshot hosters drop');
+ assert.ok(removed.every(j => j.hoster === 'doodstream.com' || j.hoster === 'voe.sx'));
+ assert.equal(kept.length, 2, 'the 2 never-started hosters survive');
+ assert.ok(kept.some(j => j.hoster === 'vidmoly.me'));
+ assert.ok(kept.some(j => j.hoster === 'byse.sx'));
+});
+
+test('completedSelectionKeys: a selectedFile that completed after the snapshot yields its full-path|hoster key', () => {
+ const selectedFiles = [{ path: 'C:/dl/done.mp4', name: 'done.mp4' }, { path: 'C:/dl/pending.mp4', name: 'pending.mp4' }];
+ const hosters = ['voe.sx'];
+ const savedAt = T('2026-06-19 12:00:00');
+ const log = [{ fileName: 'done.mp4', hoster: 'voe.sx', ts: T('2026-06-19 12:00:05') }];
+ const keys = completedSelectionKeys(selectedFiles, hosters, log, savedAt);
+ assert.deepEqual(keys, ['C:/dl/done.mp4|voe.sx'], 'only the completed file is seeded; pending is not');
+});
+
+test('completedSelectionKeys: per-hoster — a file done on voe but not byse only seeds the voe key', () => {
+ const selectedFiles = [{ path: 'C:/dl/a.mp4', name: 'a.mp4' }];
+ const hosters = ['voe.sx', 'byse.sx'];
+ const savedAt = T('2026-06-19 12:00:00');
+ const log = [{ fileName: 'a.mp4', hoster: 'voe.sx', ts: T('2026-06-19 12:00:05') }];
+ const keys = completedSelectionKeys(selectedFiles, hosters, log, savedAt);
+ assert.deepEqual(keys, ['C:/dl/a.mp4|voe.sx'], 'the still-pending byse upload is NOT seeded');
+});
+
+test('completedSelectionKeys: ambiguous basename across folders seeds NOTHING (no lost re-preview)', () => {
+ const selectedFiles = [{ path: 'C:/A/clip.mp4', name: 'clip.mp4' }, { path: 'C:/B/clip.mp4', name: 'clip.mp4' }];
+ const hosters = ['voe.sx'];
+ const savedAt = T('2026-06-19 12:00:00');
+ const log = [{ fileName: 'clip.mp4', hoster: 'voe.sx', ts: T('2026-06-19 12:00:05') }];
+ const keys = completedSelectionKeys(selectedFiles, hosters, log, savedAt);
+ assert.deepEqual(keys, [], 'ambiguous -> neither path is suppressed, both re-preview (safe direction)');
+});
+
+test('completedSelectionKeys: an OLDER completion (pre-snapshot re-queue) is NOT seeded', () => {
+ const selectedFiles = [{ path: 'C:/dl/reup.mp4', name: 'reup.mp4' }];
+ const hosters = ['voe.sx'];
+ const savedAt = T('2026-06-19 12:00:00');
+ const log = [{ fileName: 'reup.mp4', hoster: 'voe.sx', ts: T('2026-06-19 11:00:00') }];
+ assert.deepEqual(completedSelectionKeys(selectedFiles, hosters, log, savedAt), []);
+});
+
+test('completedSelectionKeys: no savedAt / junk inputs -> empty (legacy + robustness)', () => {
+ const sf = [{ path: 'C:/dl/a.mp4', name: 'a.mp4' }];
+ const log = [{ fileName: 'a.mp4', hoster: 'voe.sx', ts: T('2026-06-19 12:00:05') }];
+ assert.deepEqual(completedSelectionKeys(sf, ['voe.sx'], log, undefined), []);
+ assert.deepEqual(completedSelectionKeys(null, ['voe.sx'], log, 1), []);
+ assert.deepEqual(completedSelectionKeys(sf, null, log, 1), []);
+ assert.deepEqual(completedSelectionKeys([], [], log, 1), []);
+ assert.deepEqual(completedSelectionKeys([{ name: 'x' }], ['voe.sx'], log, 1), [], 'entry without path is skipped');
+});
+
+test('completedSelectionKeys: derives basename from path when name is missing', () => {
+ const selectedFiles = [{ path: 'C:/dl/sub/movie.mp4' }];
+ const hosters = ['voe.sx'];
+ const savedAt = T('2026-06-19 12:00:00');
+ const log = [{ fileName: 'movie.mp4', hoster: 'voe.sx', ts: T('2026-06-19 12:00:05') }];
+ assert.deepEqual(completedSelectionKeys(selectedFiles, hosters, log, savedAt), ['C:/dl/sub/movie.mp4|voe.sx']);
+});
diff --git a/tests/queue-persistence-scenario.test.js b/tests/queue-persistence-scenario.test.js
new file mode 100644
index 0000000..de02425
--- /dev/null
+++ b/tests/queue-persistence-scenario.test.js
@@ -0,0 +1,83 @@
+const { test } = require('node:test');
+const assert = require('node:assert');
+const { formatUploadLogLine, parseUploadLogLine } = require('../lib/upload-log');
+const { partitionRestoredJobsByLog } = require('../lib/queue-dedup');
+
+function makeJobs(n, hoster, status, offset = 0) {
+ const jobs = [];
+ for (let i = 0; i < n; i++) {
+ const fileName = `clip_${String(i + offset).padStart(4, '0')}.mp4`;
+ jobs.push({ id: `j-${hoster}-${i + offset}`, file: `D:/inbox/${fileName}`, fileName, hoster, status });
+ }
+ return jobs;
+}
+
+test('user report: 300 queued, ~200 finished mid-session before a hard kill — only the finished drop', () => {
+ const hoster = 'byse.sx';
+ const snapshot = new Date(2026, 5, 19, 22, 0, 0);
+ const savedAt = snapshot.getTime();
+ const restoredJobs = makeJobs(300, hoster, 'preview');
+
+ const completionBase = new Date(2026, 5, 19, 22, 5, 0).getTime();
+ const logEntries = [];
+ for (let i = 0; i < 200; i++) {
+ const d = new Date(completionBase + i * 1000);
+ logEntries.push(parseUploadLogLine(
+ formatUploadLogLine(d, hoster, `https://byse.sx/d/x${i}`, `clip_${String(i).padStart(4, '0')}.mp4`)
+ ));
+ }
+
+ const { kept, removed } = partitionRestoredJobsByLog(restoredJobs, logEntries, savedAt);
+ assert.equal(removed.length, 200, 'the 200 completed-after-snapshot files are dropped as ghosts');
+ assert.equal(kept.length, 100, 'the 100 never-finished files stay queued');
+ assert.ok(kept.every(j => Number(j.fileName.slice(5, 9)) >= 200), 'kept are exactly indices 200..299');
+ const keptNames = new Set(kept.map(j => j.fileName));
+ assert.ok(removed.every(j => !keptNames.has(j.fileName)));
+});
+
+test('multi-hoster batch: per-hoster completion is independent (a file done on voe but not byse keeps byse)', () => {
+ const savedAt = new Date(2026, 5, 19, 22, 0, 0).getTime();
+ const done = new Date(2026, 5, 19, 22, 3, 0);
+ const jobs = [
+ ...makeJobs(3, 'voe.sx', 'preview'),
+ ...makeJobs(3, 'byse.sx', 'preview')
+ ];
+ const logEntries = [
+ parseUploadLogLine(formatUploadLogLine(done, 'voe.sx', 'l', 'clip_0000.mp4')),
+ parseUploadLogLine(formatUploadLogLine(done, 'voe.sx', 'l', 'clip_0001.mp4')),
+ parseUploadLogLine(formatUploadLogLine(done, 'byse.sx', 'l', 'clip_0000.mp4'))
+ ];
+ const { kept, removed } = partitionRestoredJobsByLog(jobs, logEntries, savedAt);
+ assert.equal(removed.length, 3);
+ assert.ok(removed.some(j => j.hoster === 'voe.sx' && j.fileName === 'clip_0000.mp4'));
+ assert.ok(removed.some(j => j.hoster === 'voe.sx' && j.fileName === 'clip_0001.mp4'));
+ assert.ok(removed.some(j => j.hoster === 'byse.sx' && j.fileName === 'clip_0000.mp4'));
+ assert.ok(kept.some(j => j.hoster === 'byse.sx' && j.fileName === 'clip_0001.mp4'), 'byse clip_0001 not logged -> kept');
+});
+
+test('clean idle close (snapshot AFTER completion) keeps an intentional re-queue of an old file', () => {
+ const hoster = 'voe.sx';
+ const yesterday = new Date(2026, 5, 18, 12, 0, 0);
+ const logEntries = [parseUploadLogLine(formatUploadLogLine(yesterday, hoster, 'link', 'reupload_me.mp4'))];
+ const savedAt = new Date(2026, 5, 19, 9, 0, 0).getTime();
+ const jobs = [{ id: 'r1', file: 'D:/x/reupload_me.mp4', fileName: 'reupload_me.mp4', hoster, status: 'preview' }];
+ const { kept, removed } = partitionRestoredJobsByLog(jobs, logEntries, savedAt);
+ assert.equal(removed.length, 0, 'an upload older than the snapshot is a deliberate re-queue and survives');
+ assert.equal(kept.length, 1);
+});
+
+test('legacy snapshot without savedAt (pre-v3.3.80 config) falls back to done-only dedup', () => {
+ const hoster = 'voe.sx';
+ const logEntries = [
+ parseUploadLogLine(formatUploadLogLine(new Date(2026, 5, 19, 12, 0, 0), hoster, 'l', 'done.mp4')),
+ parseUploadLogLine(formatUploadLogLine(new Date(2026, 5, 19, 12, 1, 0), hoster, 'l', 'preview.mp4'))
+ ];
+ const jobs = [
+ { id: 'a', file: 'D:/x/done.mp4', fileName: 'done.mp4', hoster, status: 'done' },
+ { id: 'b', file: 'D:/x/preview.mp4', fileName: 'preview.mp4', hoster, status: 'preview' }
+ ];
+ const { kept, removed } = partitionRestoredJobsByLog(jobs, logEntries);
+ assert.equal(removed.length, 1, 'only the done job is decluttered when no savedAt is available');
+ assert.equal(removed[0].id, 'a');
+ assert.ok(kept.some(j => j.id === 'b'), 'the preview survives the legacy path');
+});
diff --git a/tests/queue-prune.test.js b/tests/queue-prune.test.js
new file mode 100644
index 0000000..0cf82e9
--- /dev/null
+++ b/tests/queue-prune.test.js
@@ -0,0 +1,115 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+
+const { pruneOldestTerminalJobs, TERMINAL_STATUSES } = require('../lib/queue-prune');
+
+const j = (id, status) => ({ id, status });
+
+test('returns null on empty / non-array input', () => {
+ assert.equal(pruneOldestTerminalJobs([], 5), null);
+ assert.equal(pruneOldestTerminalJobs(null, 5), null);
+ assert.equal(pruneOldestTerminalJobs(undefined, 5), null);
+});
+
+test('returns null when all jobs are non-terminal regardless of limit', () => {
+ const jobs = [j('a', 'queued'), j('b', 'uploading'), j('c', 'preview')];
+ assert.equal(pruneOldestTerminalJobs(jobs, 0), null);
+ assert.equal(pruneOldestTerminalJobs(jobs, 100), null);
+});
+
+test('returns null when terminal count is at or under the limit', () => {
+ const jobs = [j('a', 'done'), j('b', 'done'), j('c', 'queued')];
+ assert.equal(pruneOldestTerminalJobs(jobs, 2), null, 'terminal=2, limit=2 → no-op');
+ assert.equal(pruneOldestTerminalJobs(jobs, 3), null, 'terminal=2, limit=3 → no-op');
+});
+
+test('drops oldest terminal jobs when over the limit, keeps non-terminal', () => {
+ const jobs = [
+ j('t1', 'done'), // oldest terminal — should be dropped
+ j('t2', 'done'), // should be dropped
+ j('queued1', 'queued'),
+ j('t3', 'error'), // newest of the dropped block
+ j('uploading1', 'uploading'),
+ j('t4', 'done'), // kept (within limit window)
+ j('t5', 'skipped'), // kept
+ j('t6', 'aborted'), // kept
+ ];
+ // 6 terminal, limit 3 → drop 3 oldest (t1, t2, t3)
+ const result = pruneOldestTerminalJobs(jobs, 3);
+ assert.notEqual(result, null);
+ const droppedIds = result.dropped.map(x => x.id).sort();
+ assert.deepEqual(droppedIds, ['t1', 't2', 't3']);
+ // Non-terminal jobs always kept; surviving terminals are the newest 3
+ const keptIds = result.kept.map(x => x.id);
+ assert.deepEqual(keptIds, ['queued1', 'uploading1', 't4', 't5', 't6']);
+});
+
+test('respects insertion order (oldest by index, not by status)', () => {
+ const jobs = [
+ j('older-error', 'error'),
+ j('newer-done', 'done'),
+ j('newest-aborted', 'aborted'),
+ ];
+ const result = pruneOldestTerminalJobs(jobs, 1);
+ assert.deepEqual(result.dropped.map(x => x.id), ['older-error', 'newer-done']);
+ assert.deepEqual(result.kept.map(x => x.id), ['newest-aborted']);
+});
+
+test('drops everything terminal when limit is 0', () => {
+ const jobs = [
+ j('q', 'queued'),
+ j('d1', 'done'),
+ j('d2', 'done'),
+ j('e1', 'error'),
+ ];
+ const result = pruneOldestTerminalJobs(jobs, 0);
+ assert.deepEqual(result.dropped.map(x => x.id), ['d1', 'd2', 'e1']);
+ assert.deepEqual(result.kept.map(x => x.id), ['q']);
+});
+
+test('rejects negative or non-finite limits', () => {
+ const jobs = [j('a', 'done'), j('b', 'done')];
+ assert.equal(pruneOldestTerminalJobs(jobs, -1), null);
+ assert.equal(pruneOldestTerminalJobs(jobs, NaN), null);
+ assert.equal(pruneOldestTerminalJobs(jobs, Infinity), null,
+ 'Infinity is technically not finite; safer to treat as no-op');
+});
+
+test('TERMINAL_STATUSES set covers all 4 terminal kinds', () => {
+ assert.ok(TERMINAL_STATUSES.has('done'));
+ assert.ok(TERMINAL_STATUSES.has('skipped'));
+ assert.ok(TERMINAL_STATUSES.has('error'));
+ assert.ok(TERMINAL_STATUSES.has('aborted'));
+ assert.equal(TERMINAL_STATUSES.size, 4);
+ // Non-terminal must not be in the set
+ for (const s of ['queued', 'preview', 'uploading', 'retrying', 'getting-server']) {
+ assert.equal(TERMINAL_STATUSES.has(s), false, `${s} must not be terminal`);
+ }
+});
+
+test('handles malformed entries (null / missing status) without throwing', () => {
+ const jobs = [
+ null,
+ j('a', 'done'),
+ { id: 'no-status' }, // no status
+ j('b', 'done'),
+ ];
+ // 2 terminal, limit 1 → drop oldest (a). null and no-status entries stay
+ // because they aren't terminal. The function must not throw on them.
+ const result = pruneOldestTerminalJobs(jobs, 1);
+ assert.notEqual(result, null);
+ assert.deepEqual(result.dropped.map(x => x && x.id), ['a']);
+ assert.equal(result.kept.length, 3);
+});
+
+test('large queue: keeps the newest `limit` terminals', () => {
+ const jobs = [];
+ for (let i = 0; i < 5000; i++) jobs.push(j(`done-${i}`, 'done'));
+ const result = pruneOldestTerminalJobs(jobs, 500);
+ assert.notEqual(result, null);
+ assert.equal(result.dropped.length, 4500);
+ assert.equal(result.kept.length, 500);
+ // First kept = done-4500 (the 4501st original entry)
+ assert.equal(result.kept[0].id, 'done-4500');
+ assert.equal(result.kept[result.kept.length - 1].id, 'done-4999');
+});
diff --git a/tests/remote-config.test.js b/tests/remote-config.test.js
new file mode 100644
index 0000000..bfabc66
--- /dev/null
+++ b/tests/remote-config.test.js
@@ -0,0 +1,53 @@
+const { describe, it } = require('node:test');
+const assert = require('node:assert');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+// Minimal app mock for ConfigStore
+function createTestConfigStore() {
+ const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mhu-test-'));
+ const mockApp = {
+ isPackaged: false,
+ getPath: (name) => tmpDir,
+ getPath: () => tmpDir
+ };
+ const ConfigStore = require('../lib/config-store');
+ const store = new ConfigStore(mockApp);
+ store.filePath = path.join(tmpDir, 'test-config.json');
+ return { store, tmpDir };
+}
+
+describe('remote config defaults', () => {
+ it('should include remote settings in defaults', () => {
+ const { store } = createTestConfigStore();
+ const config = store.load();
+ const remote = config.globalSettings.remote;
+
+ assert.strictEqual(remote.enabled, false);
+ assert.strictEqual(remote.port, 9100);
+ assert.strictEqual(typeof remote.token, 'string');
+ assert.strictEqual(remote.token, '');
+ assert.strictEqual(remote.allowInput, true);
+ });
+
+ it('should deep-merge remote settings with existing config', async () => {
+ const { store } = createTestConfigStore();
+ // Save config with partial remote settings
+ await store.save({
+ globalSettings: {
+ remote: { enabled: true, port: 9200 }
+ }
+ });
+
+ const config = store.load();
+ const remote = config.globalSettings.remote;
+
+ // Saved values preserved
+ assert.strictEqual(remote.enabled, true);
+ assert.strictEqual(remote.port, 9200);
+ // Defaults merged in
+ assert.strictEqual(remote.allowInput, true);
+ assert.strictEqual(remote.token, '');
+ });
+});
diff --git a/tests/remote-server.test.js b/tests/remote-server.test.js
new file mode 100644
index 0000000..75a37a3
--- /dev/null
+++ b/tests/remote-server.test.js
@@ -0,0 +1,41 @@
+const { describe, it, beforeEach, afterEach } = require('node:test');
+const assert = require('node:assert');
+
+// Test the module can be required and has the expected API
+describe('RemoteServer', () => {
+ it('should export a class with start/stop methods', () => {
+ const RemoteServer = require('../lib/remote-server');
+ assert.strictEqual(typeof RemoteServer, 'function');
+ assert.strictEqual(typeof RemoteServer.prototype.start, 'function');
+ assert.strictEqual(typeof RemoteServer.prototype.stop, 'function');
+ assert.strictEqual(typeof RemoteServer.prototype.getClientCount, 'function');
+ });
+
+ it('should start and stop without errors', async () => {
+ const RemoteServer = require('../lib/remote-server');
+ const server = new RemoteServer();
+
+ // Mock mainWindow
+ const mockMainWindow = {
+ isDestroyed: () => false,
+ getTitle: () => 'Test Window',
+ getContentBounds: () => ({ x: 0, y: 0, width: 1920, height: 1080 }),
+ webContents: {
+ sendInputEvent: () => {}
+ }
+ };
+
+ await server.start({
+ port: 0, // random available port
+ token: 'test-token-123',
+ allowInput: true,
+ mainWindow: mockMainWindow,
+ onSignalingToCapture: () => {},
+ onCreateCaptureWindow: () => {},
+ onDestroyCaptureWindow: () => {}
+ });
+
+ assert.strictEqual(server.getClientCount(), 0);
+ server.stop();
+ });
+});
diff --git a/tests/semaphore.test.js b/tests/semaphore.test.js
new file mode 100644
index 0000000..91cb77f
--- /dev/null
+++ b/tests/semaphore.test.js
@@ -0,0 +1,174 @@
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+const Semaphore = require('../lib/semaphore');
+
+describe('Semaphore', () => {
+ it('clamps limit to at least 1', () => {
+ assert.equal(new Semaphore(0).limit, 1);
+ assert.equal(new Semaphore(-5).limit, 1);
+ assert.equal(new Semaphore(undefined).limit, 1);
+ assert.equal(new Semaphore(3).limit, 3);
+ });
+
+ it('acquire resolves immediately when slots available', async () => {
+ const sem = new Semaphore(2);
+ await sem.acquire();
+ await sem.acquire();
+ assert.equal(sem.active, 2);
+ });
+
+ it('acquire blocks when all slots taken', async () => {
+ const sem = new Semaphore(1);
+ await sem.acquire();
+
+ let resolved = false;
+ const p = sem.acquire().then(() => { resolved = true; });
+
+ // Give microtask a chance to resolve
+ await new Promise(r => setTimeout(r, 10));
+ assert.equal(resolved, false, 'should not resolve while slot is taken');
+ assert.equal(sem.pending, 1);
+
+ sem.release();
+ await p;
+ assert.equal(resolved, true);
+ });
+
+ it('FIFO ordering', async () => {
+ const sem = new Semaphore(1);
+ await sem.acquire(); // take the one slot
+
+ const order = [];
+ const p1 = sem.acquire().then(() => order.push(1));
+ const p2 = sem.acquire().then(() => order.push(2));
+ const p3 = sem.acquire().then(() => order.push(3));
+
+ assert.equal(sem.pending, 3);
+
+ sem.release(); await p1;
+ sem.release(); await p2;
+ sem.release(); await p3;
+
+ assert.deepEqual(order, [1, 2, 3]);
+ });
+
+ it('release with no waiters decrements active', async () => {
+ const sem = new Semaphore(2);
+ await sem.acquire();
+ assert.equal(sem.active, 1);
+ sem.release();
+ assert.equal(sem.active, 0);
+ });
+
+ it('release never goes below 0', () => {
+ const sem = new Semaphore(2);
+ sem.release();
+ assert.equal(sem.active, 0);
+ sem.release();
+ assert.equal(sem.active, 0);
+ });
+
+ it('acquire rejects immediately if signal already aborted', async () => {
+ const sem = new Semaphore(2);
+ const ac = new AbortController();
+ ac.abort();
+
+ await assert.rejects(sem.acquire(ac.signal), /Aborted/);
+ assert.equal(sem.active, 0, 'no slot should be acquired');
+ });
+
+ it('abort while waiting in queue removes entry and rejects', async () => {
+ const sem = new Semaphore(1);
+ await sem.acquire(); // take the slot
+
+ const ac = new AbortController();
+ const p = sem.acquire(ac.signal);
+
+ assert.equal(sem.pending, 1);
+ ac.abort();
+ await assert.rejects(p, /Aborted/);
+ assert.equal(sem.pending, 0, 'entry should be removed from queue');
+
+ // Release original slot - should not cause issues
+ sem.release();
+ assert.equal(sem.active, 0);
+ });
+
+ it('abort listener is cleaned up when slot is granted via release', async () => {
+ const sem = new Semaphore(1);
+ await sem.acquire();
+
+ const ac = new AbortController();
+ let rejected = false;
+ const p = sem.acquire(ac.signal).catch(() => { rejected = true; });
+
+ sem.release(); // grants slot to the waiter
+ await p;
+
+ // Now abort after the slot was already granted
+ ac.abort();
+ await new Promise(r => setTimeout(r, 10));
+ assert.equal(rejected, false, 'reject should not fire after slot was granted');
+ });
+
+ it('updateLimit wakes waiters', async () => {
+ const sem = new Semaphore(1);
+ await sem.acquire();
+
+ const resolved = [];
+ const p1 = sem.acquire().then(() => resolved.push(1));
+ const p2 = sem.acquire().then(() => resolved.push(2));
+
+ sem.updateLimit(3);
+ await Promise.all([p1, p2]);
+ assert.deepEqual(resolved, [1, 2]);
+ });
+
+ it('updateLimit to lower value does not kill active slots', async () => {
+ const sem = new Semaphore(3);
+ await sem.acquire();
+ await sem.acquire();
+ await sem.acquire();
+ assert.equal(sem.active, 3);
+
+ sem.updateLimit(1);
+ assert.equal(sem.active, 3, 'existing active slots should not be evicted');
+
+ sem.release();
+ sem.release();
+ sem.release();
+ assert.equal(sem.active, 0);
+
+ // Now only 1 slot should be available
+ await sem.acquire();
+ let blocked = false;
+ const p = sem.acquire().then(() => { blocked = true; });
+ await new Promise(r => setTimeout(r, 10));
+ assert.equal(blocked, false, 'should block at limit 1');
+ sem.release();
+ await p;
+ });
+
+ it('pending getter tracks queue size', async () => {
+ const sem = new Semaphore(1);
+ assert.equal(sem.pending, 0);
+
+ await sem.acquire();
+ sem.acquire(); // blocked
+ sem.acquire(); // blocked
+ assert.equal(sem.pending, 2);
+
+ sem.release();
+ await new Promise(r => setTimeout(r, 5));
+ assert.equal(sem.pending, 1);
+ });
+
+ it('release without acquire clamps active to 0', () => {
+ const sem = new Semaphore(2);
+ assert.equal(sem.active, 0);
+ sem.release();
+ assert.equal(sem.active, 0, 'should not go negative');
+ sem.release();
+ assert.equal(sem.active, 0, 'should still be 0');
+ });
+});
diff --git a/tests/serialized-runner.test.js b/tests/serialized-runner.test.js
new file mode 100644
index 0000000..9324bac
--- /dev/null
+++ b/tests/serialized-runner.test.js
@@ -0,0 +1,32 @@
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+
+describe('serialized runner', () => {
+ it('flush waits for an already running save and later work stays ordered', async () => {
+ const { createSerializedRunner } = require('../lib/serialized-runner');
+ let releaseFirst;
+ const calls = [];
+ const runner = createSerializedRunner(async (value) => {
+ calls.push(`start:${value}`);
+ if (value === 'first') await new Promise((resolve) => { releaseFirst = resolve; });
+ calls.push(`end:${value}`);
+ return value;
+ });
+
+ const first = runner.run('first');
+ await new Promise((resolve) => setImmediate(resolve));
+ const second = runner.run('second');
+ let flushed = false;
+ const flush = runner.flush().then(() => { flushed = true; });
+ await new Promise((resolve) => setImmediate(resolve));
+ assert.equal(flushed, false);
+ assert.deepEqual(calls, ['start:first']);
+
+ releaseFirst();
+ assert.equal(await first, 'first');
+ assert.equal(await second, 'second');
+ await flush;
+ assert.equal(flushed, true);
+ assert.deepEqual(calls, ['start:first', 'end:first', 'start:second', 'end:second']);
+ });
+});
diff --git a/tests/settings-backup.test.js b/tests/settings-backup.test.js
new file mode 100644
index 0000000..d1ddf9b
--- /dev/null
+++ b/tests/settings-backup.test.js
@@ -0,0 +1,47 @@
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+
+describe('settings backup snapshot', () => {
+ it('copies accounts and settings while excluding history, queue and rotation state', () => {
+ const { createPortableSettingsSnapshot } = require('../lib/settings-backup');
+ const input = {
+ hosters: { 'voe.sx': [{ id: 'v1', username: 'user', password: 'secret', enabled: true }] },
+ hosterSettings: { 'voe.sx': { retries: 7 } },
+ globalSettings: { alwaysOnTop: true, pendingQueue: [{ file: 'private.mkv' }] },
+ history: [{ file: 'done.mkv' }],
+ rotationCursors: { 'voe.sx': 4 }
+ };
+
+ const snapshot = createPortableSettingsSnapshot(input);
+
+ assert.deepEqual(snapshot, {
+ hosters: input.hosters,
+ hosterSettings: input.hosterSettings,
+ globalSettings: { alwaysOnTop: true, pendingQueue: null },
+ history: []
+ });
+ assert.notEqual(snapshot.hosters, input.hosters);
+ });
+
+ it('validates imports and clears only source-machine paths that do not exist locally', () => {
+ const { prepareImportedSettings } = require('../lib/settings-backup');
+ const snapshot = {
+ hosters: { 'byse.sx': [{ id: 'b1', apiKey: 'secret', enabled: true }] },
+ hosterSettings: { 'byse.sx': { parallelCount: 6 } },
+ globalSettings: {
+ alwaysOnTop: true,
+ logFilePath: 'Z:\\missing\\upload.log',
+ folderMonitor: { enabled: true, folderPath: 'Z:\\missing\\watch' },
+ pendingQueue: [{ file: 'do-not-restore.mkv' }]
+ }
+ };
+
+ const imported = prepareImportedSettings(snapshot, { pathExists: () => false, pathDirname: (value) => value });
+
+ assert.equal(imported.globalSettings.logFilePath, '');
+ assert.deepEqual(imported.globalSettings.folderMonitor, { enabled: false, folderPath: '' });
+ assert.equal(imported.globalSettings.pendingQueue, null);
+ assert.deepEqual(imported.history, []);
+ assert.throws(() => prepareImportedSettings({ hosters: {} }), /ungültige Struktur/i);
+ });
+});
diff --git a/tests/settings-import-gate.test.js b/tests/settings-import-gate.test.js
new file mode 100644
index 0000000..9bccd6d
--- /dev/null
+++ b/tests/settings-import-gate.test.js
@@ -0,0 +1,19 @@
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+
+describe('settings import gate', () => {
+ it('blocks upload starts for the complete import transition', () => {
+ const { createSettingsImportGate } = require('../lib/settings-import-gate');
+ let uploadRunning = false;
+ const gate = createSettingsImportGate(() => uploadRunning);
+
+ gate.begin();
+ assert.equal(gate.canStartUpload(), false);
+ assert.throws(() => gate.begin(), /bereits importiert/i);
+ gate.end();
+ assert.equal(gate.canStartUpload(), true);
+
+ uploadRunning = true;
+ assert.throws(() => gate.begin(), /laufender Uploads/i);
+ });
+});
diff --git a/tests/startup-renderer.test.js b/tests/startup-renderer.test.js
new file mode 100644
index 0000000..92555bc
--- /dev/null
+++ b/tests/startup-renderer.test.js
@@ -0,0 +1,68 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { EventEmitter } = require('node:events');
+const { configureStartupRenderer, createStartupWindow } = require('../lib/startup-renderer');
+
+class TestBrowserWindow extends EventEmitter {
+ constructor(options) {
+ super();
+ this.options = options;
+ this.showCalls = 0;
+ this.startupEvents = [];
+ this.loadError = new Error('renderer load failed');
+ }
+
+ once(eventName, listener) {
+ this.startupEvents.push(`listen:${eventName}`);
+ return super.once(eventName, listener);
+ }
+
+ show() {
+ this.showCalls++;
+ }
+
+ loadFile(target) {
+ this.startupEvents.push(`load:${target}`);
+ return Promise.reject(this.loadError);
+ }
+}
+
+test('configureStartupRenderer disables hardware acceleration', () => {
+ let calls = 0;
+ configureStartupRenderer({ disableHardwareAcceleration() { calls++; } });
+ assert.equal(calls, 1);
+});
+
+test('createStartupWindow forces the main window to start hidden', () => {
+ const startup = createStartupWindow(TestBrowserWindow, { width: 1100, show: true });
+
+ assert.equal(startup.window.options.width, 1100);
+ assert.equal(startup.window.options.show, false);
+});
+
+test('startup load registers visibility before navigation and shows only once', async () => {
+ const startup = createStartupWindow(TestBrowserWindow, {});
+ const loading = startup.load('renderer/index.html', () => {});
+
+ assert.deepEqual(startup.window.startupEvents, [
+ 'listen:ready-to-show',
+ 'load:renderer/index.html'
+ ]);
+
+ startup.window.emit('ready-to-show');
+ startup.window.emit('ready-to-show');
+ await loading;
+
+ assert.equal(startup.window.showCalls, 1);
+});
+
+test('startup load forwards a rejected navigation to the error handler', async () => {
+ const startup = createStartupWindow(TestBrowserWindow, {});
+ let handledError;
+
+ await startup.load('renderer/index.html', (err) => {
+ handledError = err;
+ });
+
+ assert.equal(handledError, startup.window.loadError);
+});
diff --git a/tests/stats.test.js b/tests/stats.test.js
new file mode 100644
index 0000000..2dd4dab
--- /dev/null
+++ b/tests/stats.test.js
@@ -0,0 +1,132 @@
+const test = require('node:test');
+const assert = require('node:assert');
+const {
+ summarizePerHoster,
+ classifyErrorCategory,
+ summarizeBatchErrors,
+ isRetryableCategory
+} = require('../lib/stats');
+
+function makeBatch(timestamp, results) {
+ return {
+ id: 'b-' + timestamp,
+ timestamp: new Date(timestamp).toISOString(),
+ files: [{ name: 'foo.mp4', size: 1, results }]
+ };
+}
+
+test('summarizePerHoster counts ok and fail per hoster across all batches', () => {
+ const history = [
+ makeBatch(1, [
+ { hoster: 'voe.sx', status: 'done' },
+ { hoster: 'byse.sx', status: 'error', error: 'Not video file format' }
+ ]),
+ makeBatch(2, [
+ { hoster: 'voe.sx', status: 'done' },
+ { hoster: 'voe.sx', status: 'error', error: 'CSRF' },
+ { hoster: 'byse.sx', status: 'done' }
+ ])
+ ];
+ const s = summarizePerHoster(history);
+ assert.strictEqual(s['voe.sx'].ok, 2);
+ assert.strictEqual(s['voe.sx'].fail, 1);
+ assert.strictEqual(s['voe.sx'].total, 3);
+ assert.strictEqual(Math.round(s['voe.sx'].rate * 100), 67);
+ assert.strictEqual(s['byse.sx'].ok, 1);
+ assert.strictEqual(s['byse.sx'].fail, 1);
+ assert.strictEqual(s['byse.sx'].rate, 0.5);
+});
+
+test('summarizePerHoster honors sinceMs cutoff', () => {
+ const history = [
+ makeBatch(1000, [{ hoster: 'voe.sx', status: 'done' }]),
+ makeBatch(5000, [{ hoster: 'voe.sx', status: 'error', error: 'x' }])
+ ];
+ const s = summarizePerHoster(history, { sinceMs: 3000 });
+ assert.strictEqual(s['voe.sx'].ok, 0);
+ assert.strictEqual(s['voe.sx'].fail, 1);
+});
+
+test('summarizePerHoster honors lastNBatches (newest first)', () => {
+ const history = [
+ makeBatch(1000, [{ hoster: 'voe.sx', status: 'done' }]),
+ makeBatch(2000, [{ hoster: 'voe.sx', status: 'done' }]),
+ makeBatch(3000, [{ hoster: 'voe.sx', status: 'error', error: 'x' }])
+ ];
+ const s = summarizePerHoster(history, { lastNBatches: 1 });
+ assert.strictEqual(s['voe.sx'].ok, 0);
+ assert.strictEqual(s['voe.sx'].fail, 1);
+});
+
+test('summarizePerHoster handles empty / malformed input', () => {
+ assert.deepStrictEqual(summarizePerHoster(null), {});
+ assert.deepStrictEqual(summarizePerHoster([]), {});
+ assert.deepStrictEqual(summarizePerHoster([{ id: 'x', files: null }]), {});
+});
+
+test('classifyErrorCategory: file-rejected phrases', () => {
+ assert.strictEqual(classifyErrorCategory('Byse lehnte Datei ab: Not video file format'), 'file-rejected');
+ assert.strictEqual(classifyErrorCategory('Duplicate file already exists'), 'file-rejected');
+ assert.strictEqual(classifyErrorCategory('Datei zu groß (Max: 5 GB)'), 'file-rejected');
+});
+
+test('classifyErrorCategory: account-error phrases', () => {
+ assert.strictEqual(classifyErrorCategory('Quota exceeded'), 'account-error');
+ assert.strictEqual(classifyErrorCategory('account banned'), 'account-error');
+ assert.strictEqual(classifyErrorCategory('not enough disk space'), 'account-error');
+});
+
+test('classifyErrorCategory: hoster-transient phrases', () => {
+ assert.strictEqual(classifyErrorCategory('CSRF-Token nicht gefunden'), 'hoster-transient');
+ assert.strictEqual(classifyErrorCategory('Kein Upload-Server erhalten: server busy'), 'hoster-transient');
+ assert.strictEqual(classifyErrorCategory('Kein Filecode'), 'hoster-transient');
+});
+
+test('classifyErrorCategory: network phrases', () => {
+ assert.strictEqual(classifyErrorCategory('socket hang up'), 'network');
+ assert.strictEqual(classifyErrorCategory('fetch failed'), 'network');
+ assert.strictEqual(classifyErrorCategory('Timeout while reading'), 'network');
+});
+
+test('classifyErrorCategory: aborted is its own bucket (not retryable)', () => {
+ assert.strictEqual(classifyErrorCategory('Abgebrochen'), 'aborted');
+ assert.strictEqual(isRetryableCategory('aborted'), false);
+});
+
+test('classifyErrorCategory: unknown for everything else', () => {
+ assert.strictEqual(classifyErrorCategory(''), 'unknown');
+ assert.strictEqual(classifyErrorCategory(null), 'unknown');
+ assert.strictEqual(classifyErrorCategory('Some weird thing'), 'unknown');
+});
+
+test('summarizeBatchErrors buckets results by category', () => {
+ const summary = {
+ files: [
+ { name: 'a.mp4', results: [
+ { hoster: 'voe.sx', status: 'done' },
+ { hoster: 'byse.sx', status: 'error', error: 'Not video file format' }
+ ] },
+ { name: 'b.mp4', results: [
+ { hoster: 'voe.sx', status: 'error', error: 'CSRF' },
+ { hoster: 'doodstream.com', status: 'error', error: 'socket hang up' }
+ ] }
+ ]
+ };
+ const buckets = summarizeBatchErrors(summary);
+ assert.strictEqual(buckets['file-rejected'].length, 1);
+ assert.strictEqual(buckets['file-rejected'][0].hoster, 'byse.sx');
+ assert.strictEqual(buckets['hoster-transient'].length, 1);
+ assert.strictEqual(buckets['hoster-transient'][0].hoster, 'voe.sx');
+ assert.strictEqual(buckets['network'].length, 1);
+ assert.strictEqual(buckets['network'][0].hoster, 'doodstream.com');
+ assert.strictEqual(buckets['account-error'].length, 0);
+});
+
+test('isRetryableCategory: only transient + network + unknown retry-worthy', () => {
+ assert.strictEqual(isRetryableCategory('hoster-transient'), true);
+ assert.strictEqual(isRetryableCategory('network'), true);
+ assert.strictEqual(isRetryableCategory('unknown'), true);
+ assert.strictEqual(isRetryableCategory('file-rejected'), false);
+ assert.strictEqual(isRetryableCategory('account-error'), false);
+ assert.strictEqual(isRetryableCategory('aborted'), false);
+});
diff --git a/tests/support-bundle.test.js b/tests/support-bundle.test.js
new file mode 100644
index 0000000..a803d37
--- /dev/null
+++ b/tests/support-bundle.test.js
@@ -0,0 +1,155 @@
+const test = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { sanitizeConfig, collectFile, buildSupportBundleText, redactLogText, REDACTED } = require('../lib/support-bundle');
+
+test('sanitizeConfig redacts known credential keys at any nesting depth', () => {
+ const input = {
+ hosters: {
+ 'voe.sx': [{ username: 'u', password: 'p1', apiKey: 'k1', enabled: true }],
+ 'byse.sx': [{ apiKey: 'k2' }, { apiKey: 'k3', token: 't1', label: 'main' }]
+ },
+ globalSettings: { remote: { token: 'remT' }, scramble: { active: false } }
+ };
+ const out = sanitizeConfig(input);
+ assert.strictEqual(out.hosters['voe.sx'][0].password, REDACTED);
+ assert.strictEqual(out.hosters['voe.sx'][0].apiKey, REDACTED);
+ assert.strictEqual(out.hosters['voe.sx'][0].username, 'u');
+ assert.strictEqual(out.hosters['voe.sx'][0].enabled, true);
+ assert.strictEqual(out.hosters['byse.sx'][1].apiKey, REDACTED);
+ assert.strictEqual(out.hosters['byse.sx'][1].token, REDACTED);
+ assert.strictEqual(out.hosters['byse.sx'][1].label, 'main');
+ assert.strictEqual(out.globalSettings.remote.token, REDACTED);
+});
+
+test('redactLogText scrubs opaque tokens that are NOT stored config secrets', () => {
+ const field = ['to', 'ken'].join('');
+ const cases = [
+ `boom ${field}=${['bearer', 'tok', 'qwerty12345'].join('_')}`,
+ `response auth_${field}: ${['aGVsbG8t', 'd29ybGQt', 'MTIz'].join('')}`,
+ `refresh_${field} = ${['abc123', 'DEF456', 'ghi789'].join('')}`,
+ `using Bearer ${['aaaa', 'bbbb', 'cccc', 'dddd', 'eeee', 'ffff'].join('')}`,
+ `Authorization: Bearer ${['deadbeef', 'cafef00d', 'ba5e'].join('')}`
+ ];
+ for (const line of cases) {
+ const out = redactLogText(line, []);
+ assert.ok(out.includes(REDACTED), `expected redaction in: ${line} -> ${out}`);
+ assert.ok(!/qwerty12345|aGVsbG8|abc123DEF456|aaaabbbbcccc|deadbeefcafe/.test(out), `secret survived: ${out}`);
+ }
+});
+
+test('redactLogText leaves benign "token" prose alone', () => {
+ const benign = 'token bucket refill rate is 5 per second';
+ assert.equal(redactLogText(benign, []), benign);
+});
+
+test('redactLogText scrubs the password from a basic-auth URL but keeps host:port', () => {
+ const credential = ['Sup3r', 'Proxy', 'Pass'].join('');
+ const out = redactLogText(`proxy https://admin:${credential}@proxy.internal:8080/path`, []);
+ assert.ok(!out.includes(credential), 'basic-auth password must be redacted');
+ assert.ok(out.includes('proxy.internal:8080'), 'host:port preserved');
+ assert.ok(out.includes('admin:'), 'username preserved');
+});
+
+test('redactLogText does not touch a host:port URL without userinfo', () => {
+ const url = 'connecting to https://cdn.voe.sx:8080/upload now';
+ assert.equal(redactLogText(url, []), url);
+});
+
+test('redactLogText scrubs Basic auth, JWTs and bare session= values (defense in depth)', () => {
+ const basic = ['dXNlcjpw', 'YXNzd29y', 'ZDEyMw=='].join('');
+ const jwt = [
+ ['eyJhbGci', 'OiJIUzI1NiJ9'].join(''),
+ ['eyJzdWIi', 'OiIxMjM0', 'NTY3ODkwIn0'].join(''),
+ ['dozjgNry', 'P4J3jVmN', 'Hl0w5N'].join('')
+ ].join('.');
+ const sessionA = ['SESSION', 'secret', 'value', '99887766'].join('');
+ const sessionB = ['json', 'Session', 'Secret', '123456'].join('');
+ const cases = [
+ { line: `Authorization: Basic ${basic}`, secret: basic.replace(/==$/, '') },
+ { line: `jwt ${jwt}`, secret: jwt.split('.').slice(0, 2).join('.') },
+ { line: `session=${sessionA}`, secret: sessionA },
+ { line: `"session":"${sessionB}"`, secret: sessionB },
+ ];
+ for (const c of cases) {
+ const out = redactLogText(c.line, []);
+ assert.ok(!out.includes(c.secret), `must redact: ${c.line} -> ${out}`);
+ assert.ok(out.includes(REDACTED), `expected ${REDACTED} in ${out}`);
+ }
+});
+
+test('redactLogText leaves a normal "session" word in prose alone', () => {
+ const benign = 'the session was idle for a while';
+ assert.equal(redactLogText(benign, []), benign);
+});
+
+test('sanitizeConfig does not mutate input', () => {
+ const input = { hosters: { 'voe.sx': [{ password: 'secret' }] } };
+ const clone = JSON.parse(JSON.stringify(input));
+ sanitizeConfig(input);
+ assert.deepStrictEqual(input, clone);
+});
+
+test('sanitizeConfig leaves empty/missing credentials alone', () => {
+ const input = { hosters: { 'voe.sx': [{ password: '', apiKey: null }] } };
+ const out = sanitizeConfig(input);
+ assert.strictEqual(out.hosters['voe.sx'][0].password, '');
+ assert.strictEqual(out.hosters['voe.sx'][0].apiKey, null);
+});
+
+test('sanitizeConfig handles null/undefined input', () => {
+ assert.strictEqual(sanitizeConfig(null), null);
+ assert.strictEqual(sanitizeConfig(undefined), undefined);
+});
+
+test('collectFile tails when file exceeds maxBytes', () => {
+ const tmp = path.join(os.tmpdir(), `mhu-bundle-${Date.now()}.log`);
+ const bigLine = 'x'.repeat(1000) + '\n';
+ fs.writeFileSync(tmp, bigLine.repeat(100));
+ try {
+ const section = collectFile(tmp, 'big.log', 5000);
+ assert.match(section, /truncated: skipped first \d+ bytes/);
+ assert.ok(section.length < bigLine.length * 100, 'section should be truncated');
+ } finally {
+ fs.unlinkSync(tmp);
+ }
+});
+
+test('collectFile returns placeholder for missing file', () => {
+ const section = collectFile(path.join(os.tmpdir(), `does-not-exist-${Date.now()}.log`), 'missing');
+ assert.match(section, //);
+});
+
+test('collectFile returns placeholder for null path', () => {
+ const section = collectFile(null, 'no-path');
+ assert.match(section, //);
+});
+
+test('buildSupportBundleText produces structured output with header + config + file sections', () => {
+ const tmp = path.join(os.tmpdir(), `mhu-bundle-text-${Date.now()}.log`);
+ fs.writeFileSync(tmp, 'line one\nline two\n');
+ try {
+ const text = buildSupportBundleText({
+ header: { Version: '3.3.41', Platform: 'win32' },
+ sanitizedConfig: { hosters: { 'voe.sx': [{ apiKey: '' }] } },
+ files: [{ label: 'debug.log', path: tmp }]
+ });
+ assert.match(text, /^=== Multi-Hoster-Upload Support Bundle ===/);
+ assert.match(text, /Version: 3\.3\.41/);
+ assert.match(text, /Platform: win32/);
+ assert.match(text, /=== Config \(sanitized/);
+ assert.match(text, /"apiKey": ""/);
+ assert.match(text, /=== debug\.log/);
+ assert.match(text, /line one\nline two/);
+ } finally {
+ fs.unlinkSync(tmp);
+ }
+});
+
+test('buildSupportBundleText handles empty file list and missing header', () => {
+ const text = buildSupportBundleText({ sanitizedConfig: {}, files: [] });
+ assert.match(text, /=== Multi-Hoster-Upload Support Bundle ===/);
+ assert.match(text, /=== Config/);
+});
diff --git a/tests/suspect-reject-alternates.test.js b/tests/suspect-reject-alternates.test.js
new file mode 100644
index 0000000..75139ea
--- /dev/null
+++ b/tests/suspect-reject-alternates.test.js
@@ -0,0 +1,286 @@
+const { describe, it, beforeEach, mock } = require('node:test');
+const assert = require('node:assert/strict');
+
+describe('suspect-reject alternate accounts', () => {
+ let UploadManager;
+ let mockUploadFile;
+ let mockProbe;
+
+ function suspectErr() {
+ const e = new Error('Byse lehnte Datei ab: Not video file format');
+ e.fileRejected = true;
+ e.suspectReject = true;
+ return e;
+ }
+
+ beforeEach(() => {
+ delete require.cache[require.resolve('../lib/upload-manager')];
+
+ const hosters = require('../lib/hosters');
+ mockUploadFile = mock.fn(async () => ({ download_url: 'https://byse.sx/d/ok', embed_url: null, file_code: 'ok' }));
+ hosters.uploadFile = (...a) => mockUploadFile(...a);
+ hosters.prefetchBaseline = async () => null;
+
+ const fileProbe = require('../lib/file-probe');
+ mockProbe = mock.fn(async () => ({ ok: true, kind: 'matroska', isVideoLike: true, headHex: '1a45dfa3' }));
+ fileProbe.probeFileHead = (...a) => mockProbe(...a);
+
+ const fs = require('fs');
+ const fakeSize = (p) => {
+ const m = /-(\d+)gb/i.exec(p);
+ return { size: (m ? parseInt(m[1], 10) : 3) * 1024 * 1024 * 1024 };
+ };
+ const origStatSync = fs.statSync;
+ fs.statSync = function (p) {
+ if (typeof p === 'string' && p.startsWith('/test/')) return fakeSize(p);
+ return origStatSync.call(this, p);
+ };
+ const origStat = fs.promises.stat;
+ fs.promises.stat = async function (p) {
+ if (typeof p === 'string' && p.startsWith('/test/')) return fakeSize(p);
+ return origStat.call(this, p);
+ };
+
+ UploadManager = require('../lib/upload-manager');
+ });
+
+ function poolMgr(pool, settings) {
+ return new UploadManager({ 'byse.sx': { retries: 0, ...(settings || {}) } }, {}, { 'byse.sx': pool });
+ }
+
+ it('tries the file on the next pool account after a suspect rejection and succeeds without blacklisting', async () => {
+ const mgr = poolMgr([
+ { id: 'acc1', apiKey: 'key1' },
+ { id: 'acc2', apiKey: 'key2' }
+ ]);
+ mockUploadFile.mock.mockImplementation(async (hoster, file, apiKey) => {
+ if (apiKey === 'key1') throw suspectErr();
+ return { download_url: 'https://byse.sx/d/alt', embed_url: null, file_code: 'alt' };
+ });
+ const rotEvents = [];
+ mgr.on('rot-log', (e) => rotEvents.push(e.event));
+ let summary = null;
+ mgr.on('batch-done', (s) => { summary = s; });
+
+ await mgr.startBatch([{ file: '/test/big.mkv', hoster: 'byse.sx', apiKey: 'key1', accountId: 'acc1' }]);
+
+ assert.equal(summary.succeeded, 1);
+ assert.equal(summary.failed, 0);
+ const keys = mockUploadFile.mock.calls.map(c => c.arguments[2]);
+ assert.deepEqual(keys, ['key1', 'key2']);
+ assert.ok(rotEvents.includes('suspect-reject-alt'));
+ assert.equal(mgr.getFailedAccountKeys().length, 0, 'suspect rejection must not blacklist any account');
+ });
+
+ it('fails the file when every pool account gives the suspect rejection — each tried exactly once, none blacklisted', async () => {
+ const mgr = poolMgr([
+ { id: 'acc1', apiKey: 'key1' },
+ { id: 'acc2', apiKey: 'key2' },
+ { id: 'acc3', apiKey: 'key3' }
+ ]);
+ mockUploadFile.mock.mockImplementation(async () => { throw suspectErr(); });
+ const rotEvents = [];
+ mgr.on('rot-log', (e) => rotEvents.push(e.event));
+ let summary = null;
+ mgr.on('batch-done', (s) => { summary = s; });
+
+ await mgr.startBatch([{ file: '/test/big.mkv', hoster: 'byse.sx', apiKey: 'key1', accountId: 'acc1' }]);
+
+ assert.equal(summary.failed, 1);
+ const keys = mockUploadFile.mock.calls.map(c => c.arguments[2]);
+ assert.deepEqual(keys, ['key1', 'key2', 'key3']);
+ assert.ok(rotEvents.includes('suspect-reject-exhausted'));
+ assert.equal(mgr.getFailedAccountKeys().length, 0);
+ });
+
+ it('skips pool accounts already marked failed and lands on the last one', async () => {
+ const mgr = poolMgr([
+ { id: 'acc1', apiKey: 'key1' },
+ { id: 'acc2', apiKey: 'key2' },
+ { id: 'acc3', apiKey: 'key3' },
+ { id: 'acc4', apiKey: 'key4' }
+ ]);
+ mockUploadFile.mock.mockImplementation(async (hoster, file, apiKey) => {
+ if (apiKey === 'key3') throw suspectErr();
+ return { download_url: 'https://byse.sx/d/four', embed_url: null, file_code: 'four' };
+ });
+ let summary = null;
+ mgr.on('batch-done', (s) => { summary = s; });
+
+ await mgr.startBatch(
+ [{ file: '/test/big.mkv', hoster: 'byse.sx', apiKey: 'key3', accountId: 'acc3' }],
+ { primeFailedAccounts: ['byse.sx:acc1', 'byse.sx:acc2'] }
+ );
+
+ assert.equal(summary.succeeded, 1);
+ const keys = mockUploadFile.mock.calls.map(c => c.arguments[2]);
+ assert.deepEqual(keys, ['key3', 'key4'], 'failed acc1/acc2 skipped, fourth account finally gets the file');
+ });
+
+ it('does NOT try alternates when the probe says the file is not a video', async () => {
+ mockProbe.mock.mockImplementation(async () => ({ ok: true, kind: 'rar', isVideoLike: false, headHex: '52617221' }));
+ const mgr = poolMgr([
+ { id: 'acc1', apiKey: 'key1' },
+ { id: 'acc2', apiKey: 'key2' }
+ ]);
+ mockUploadFile.mock.mockImplementation(async () => { throw suspectErr(); });
+ const rotEvents = [];
+ mgr.on('rot-log', (e) => rotEvents.push(e.event));
+ let summary = null;
+ mgr.on('batch-done', (s) => { summary = s; });
+
+ await mgr.startBatch([{ file: '/test/archive.rar', hoster: 'byse.sx', apiKey: 'key1', accountId: 'acc1' }]);
+
+ assert.equal(summary.failed, 1);
+ assert.equal(mockUploadFile.mock.calls.length, 1, 'genuine non-video rejection must not burn uploads on other accounts');
+ assert.ok(rotEvents.includes('skip-rotation-file-rejected'));
+ });
+
+ it('records a user cancel during the alternates walk as aborted, not error', async () => {
+ const mgr = poolMgr([
+ { id: 'acc1', apiKey: 'key1' },
+ { id: 'acc2', apiKey: 'key2' }
+ ]);
+ mockUploadFile.mock.mockImplementation(async (hoster, file, apiKey) => {
+ if (apiKey === 'key1') throw suspectErr();
+ mgr.cancel();
+ const e = new Error('This operation was aborted');
+ throw e;
+ });
+ let summary = null;
+ mgr.on('batch-done', (s) => { summary = s; });
+
+ await mgr.startBatch([{ file: '/test/big.mkv', hoster: 'byse.sx', apiKey: 'key1', accountId: 'acc1' }]);
+
+ assert.equal(summary.files[0].results[0].status, 'aborted');
+ });
+
+ it('marks an alternate failed on a genuine account error so later suspect files skip it', async () => {
+ const mgr = poolMgr([
+ { id: 'acc1', apiKey: 'key1' },
+ { id: 'acc2', apiKey: 'key2' },
+ { id: 'acc3', apiKey: 'key3' }
+ ], { parallelCount: 1 });
+ mockUploadFile.mock.mockImplementation(async (hoster, file, apiKey) => {
+ if (apiKey === 'key1') throw suspectErr();
+ if (apiKey === 'key2') {
+ const e = new Error('Byse lehnte Datei ab: 0:0:0:not enough disk space on your account');
+ e.accountError = true;
+ throw e;
+ }
+ return { download_url: 'https://byse.sx/d/three', embed_url: null, file_code: 'three' };
+ });
+ let summary = null;
+ mgr.on('batch-done', (s) => { summary = s; });
+
+ await mgr.startBatch([
+ { file: '/test/big1.mkv', hoster: 'byse.sx', apiKey: 'key1', accountId: 'acc1' },
+ { file: '/test/big2.mkv', hoster: 'byse.sx', apiKey: 'key1', accountId: 'acc1' }
+ ]);
+
+ assert.equal(summary.succeeded, 2);
+ assert.ok(mgr.getFailedAccountKeys().includes('byse.sx:acc2'), 'dead alternate must be remembered');
+ const keys = mockUploadFile.mock.calls.map(c => c.arguments[2]);
+ assert.deepEqual(keys, ['key1', 'key2', 'key3', 'key1', 'key3'], 'second same-size file still gets one real attempt on the primary (memo arms only on the 2nd rejection), then skips the dead alternate and lands on the good account');
+ });
+
+ it('size memo short-circuits a later LARGER file once the account has two confirmed rejections', async () => {
+ const mgr = poolMgr([
+ { id: 'acc1', apiKey: 'key1' },
+ { id: 'acc2', apiKey: 'key2' },
+ { id: 'acc3', apiKey: 'key3' }
+ ], { parallelCount: 1 });
+ mockUploadFile.mock.mockImplementation(async (hoster, file, apiKey) => {
+ if (apiKey === 'key1' || apiKey === 'key2') throw suspectErr();
+ return { download_url: 'https://byse.sx/d/three', embed_url: null, file_code: 'three' };
+ });
+ const rotEvents = [];
+ mgr.on('rot-log', (e) => rotEvents.push(e.event));
+ let summary = null;
+ mgr.on('batch-done', (s) => { summary = s; });
+
+ await mgr.startBatch([
+ { file: '/test/a-1gb.mkv', hoster: 'byse.sx', apiKey: 'key1', accountId: 'acc1' },
+ { file: '/test/b-1gb.mkv', hoster: 'byse.sx', apiKey: 'key1', accountId: 'acc1' },
+ { file: '/test/c-2gb.mkv', hoster: 'byse.sx', apiKey: 'key1', accountId: 'acc1' }
+ ]);
+
+ assert.equal(summary.succeeded, 3);
+ const keys = mockUploadFile.mock.calls.map(c => c.arguments[2]);
+ assert.deepEqual(keys, ['key1', 'key2', 'key3', 'key1', 'key3', 'key3'], 'files 1+2 each get a real attempt on the 1GB-rejecting primary (arming the memo at count 2); the larger 3rd file then short-circuits the primary straight to the good account');
+ assert.ok(rotEvents.includes('suspect-memo-skip'), 'the larger third file must skip its primary via the armed size memo');
+ });
+
+ it('sizeMemoEnabled:false disables the pre-skip — the larger third file still gets a real attempt on its primary', async () => {
+ const mgr = poolMgr([
+ { id: 'acc1', apiKey: 'key1' },
+ { id: 'acc2', apiKey: 'key2' },
+ { id: 'acc3', apiKey: 'key3' }
+ ], { parallelCount: 1, sizeMemoEnabled: false });
+ mockUploadFile.mock.mockImplementation(async (hoster, file, apiKey) => {
+ if (apiKey === 'key1' || apiKey === 'key2') throw suspectErr();
+ return { download_url: 'https://byse.sx/d/three', embed_url: null, file_code: 'three' };
+ });
+ const rotEvents = [];
+ mgr.on('rot-log', (e) => rotEvents.push(e.event));
+ let summary = null;
+ mgr.on('batch-done', (s) => { summary = s; });
+
+ await mgr.startBatch([
+ { file: '/test/a-1gb.mkv', hoster: 'byse.sx', apiKey: 'key1', accountId: 'acc1' },
+ { file: '/test/b-1gb.mkv', hoster: 'byse.sx', apiKey: 'key1', accountId: 'acc1' },
+ { file: '/test/c-2gb.mkv', hoster: 'byse.sx', apiKey: 'key1', accountId: 'acc1' }
+ ]);
+
+ assert.equal(summary.succeeded, 3);
+ const keys = mockUploadFile.mock.calls.map(c => c.arguments[2]);
+ assert.equal(keys.filter(k => k === 'key1').length, 3, 'with the memo off every file gets a real attempt on the primary — including the larger third');
+ assert.ok(!rotEvents.includes('suspect-memo-skip'), 'the disabled memo must never short-circuit a primary');
+ });
+
+ it('plain fileRejected without suspect flag keeps the old fast-fail behavior', async () => {
+ const mgr = poolMgr([
+ { id: 'acc1', apiKey: 'key1' },
+ { id: 'acc2', apiKey: 'key2' }
+ ]);
+ mockUploadFile.mock.mockImplementation(async () => {
+ const e = new Error('Byse lehnte Datei ab: Duplicate');
+ e.fileRejected = true;
+ throw e;
+ });
+ let summary = null;
+ mgr.on('batch-done', (s) => { summary = s; });
+
+ await mgr.startBatch([{ file: '/test/big.mkv', hoster: 'byse.sx', apiKey: 'key1', accountId: 'acc1' }]);
+
+ assert.equal(summary.failed, 1);
+ assert.equal(mockUploadFile.mock.calls.length, 1);
+ });
+
+ it('a transient 5xx (byse 502) retries the SAME account and fails clean — no blacklist, no failover cascade', async () => {
+ const mgr = poolMgr([
+ { id: 'acc1', apiKey: 'key1' },
+ { id: 'acc2', apiKey: 'key2' },
+ { id: 'acc3', apiKey: 'key3' }
+ ], { retries: 2 });
+ mgr._sleep = async () => {};
+ mockUploadFile.mock.mockImplementation(async () => {
+ const e = new Error('Upload-Antwort von byse.sx war kein JSON (HTTP 502): ');
+ e.transientNetwork = true;
+ throw e;
+ });
+ let accountFailed = 0;
+ mgr.on('account-failed', () => { accountFailed++; });
+ let summary = null;
+ mgr.on('batch-done', (s) => { summary = s; });
+
+ await mgr.startBatch([{ file: '/test/big.mkv', hoster: 'byse.sx', apiKey: 'key1', accountId: 'acc1' }]);
+
+ assert.equal(summary.failed, 1);
+ assert.equal(accountFailed, 0, 'a transient 502 must never emit account-failed');
+ assert.equal(mgr.getFailedAccountKeys().length, 0, 'no account blacklisted on a transient 502');
+ const keys = mockUploadFile.mock.calls.map(c => c.arguments[2]);
+ assert.ok(keys.length >= 2, 'the 502 is retried on the same account');
+ assert.ok(keys.every(k => k === 'key1'), 'every attempt stays on the primary — no cascade to key2/key3');
+ });
+});
diff --git a/tests/throttle-timer.test.js b/tests/throttle-timer.test.js
new file mode 100644
index 0000000..4ad4c82
--- /dev/null
+++ b/tests/throttle-timer.test.js
@@ -0,0 +1,133 @@
+const { test } = require('node:test');
+const assert = require('node:assert');
+const { makeThrottleTimer } = require('../lib/throttle-timer');
+
+function fakeClock() {
+ let t = 0;
+ let timers = [];
+ return {
+ now: () => t,
+ schedule: (cb, ms) => {
+ const h = { at: t + ms, cb, dead: false };
+ timers.push(h);
+ return h;
+ },
+ clear: (h) => { if (h) h.dead = true; },
+ advance: (ms) => {
+ const target = t + ms;
+ for (;;) {
+ let next = null;
+ for (const h of timers) {
+ if (!h.dead && h.at <= target && (next === null || h.at < next.at)) next = h;
+ }
+ if (!next) break;
+ t = next.at;
+ next.dead = true;
+ next.cb();
+ }
+ t = target;
+ timers = timers.filter(h => !h.dead);
+ }
+ };
+}
+
+test('idle debounce: fires once after the delay window', () => {
+ const c = fakeClock();
+ const tt = makeThrottleTimer(c);
+ let fired = 0;
+ tt.request(() => fired++, 500);
+ c.advance(499);
+ assert.equal(fired, 0);
+ c.advance(1);
+ assert.equal(fired, 1);
+});
+
+test('idle debounce: rapid requests reset the timer (last wins)', () => {
+ const c = fakeClock();
+ const tt = makeThrottleTimer(c);
+ let fired = 0;
+ tt.request(() => fired++, 500);
+ c.advance(200);
+ tt.request(() => fired++, 500);
+ c.advance(300);
+ assert.equal(fired, 0, 'should not fire at original 500 — was reset');
+ c.advance(200);
+ assert.equal(fired, 1, 'fires 500ms after the second request');
+});
+
+test('STARVATION repro: continuous requests with no maxWait NEVER fire', () => {
+ const c = fakeClock();
+ const tt = makeThrottleTimer(c);
+ let fired = 0;
+ for (let i = 0; i < 30; i++) {
+ tt.request(() => fired++, 500);
+ c.advance(100);
+ }
+ assert.equal(fired, 0, 'this is exactly the bug the maxWait fix addresses');
+});
+
+test('maxWait: continuous requests still force a fire within the window', () => {
+ const c = fakeClock();
+ const tt = makeThrottleTimer(c);
+ let fired = 0;
+ const fireAtTimes = [];
+ for (let i = 0; i < 30; i++) {
+ tt.request(() => { fired++; fireAtTimes.push(c.now()); }, 500, 2000);
+ c.advance(100);
+ }
+ assert.ok(fired >= 1, 'maxWait guarantees at least one fire under continuous load');
+ assert.ok(fireAtTimes.every(t => t > 0), 'fires happened, not starved');
+ assert.ok(fireAtTimes.some(t => t <= 2000), 'first fire no later than maxWait');
+});
+
+test('maxWait: after a forced fire a fresh burst starts (periodic fires)', () => {
+ const c = fakeClock();
+ const tt = makeThrottleTimer(c);
+ let fired = 0;
+ for (let i = 0; i < 60; i++) {
+ tt.request(() => fired++, 500, 2000);
+ c.advance(100);
+ }
+ assert.ok(fired >= 2, `~6000ms of continuous load with 2000ms maxWait should fire multiple times, got ${fired}`);
+});
+
+test('flushSync fires the pending fn immediately and clears it', () => {
+ const c = fakeClock();
+ const tt = makeThrottleTimer(c);
+ let fired = 0;
+ tt.request(() => fired++, 5000);
+ assert.ok(tt.isPending());
+ tt.flushSync();
+ assert.equal(fired, 1);
+ assert.ok(!tt.isPending());
+ c.advance(10000);
+ assert.equal(fired, 1, 'no double fire after flushSync');
+});
+
+test('cancel drops the pending fn — no fire', () => {
+ const c = fakeClock();
+ const tt = makeThrottleTimer(c);
+ let fired = 0;
+ tt.request(() => fired++, 500);
+ tt.cancel();
+ assert.ok(!tt.isPending());
+ c.advance(10000);
+ assert.equal(fired, 0);
+});
+
+test('last-write-wins: a later request with a DIFFERENT fn replaces the earlier one', () => {
+ const c = fakeClock();
+ const tt = makeThrottleTimer(c);
+ const fired = [];
+ tt.request(() => fired.push('persist'), 500, 20000);
+ c.advance(100);
+ tt.request(() => fired.push('clear'), 0);
+ c.advance(100);
+ assert.deepEqual(fired, ['clear'], 'only the latest fn fires; the persist was dropped');
+});
+
+test('flushSync with nothing pending is a no-op', () => {
+ const c = fakeClock();
+ const tt = makeThrottleTimer(c);
+ assert.doesNotThrow(() => tt.flushSync());
+});
diff --git a/tests/throttle.test.js b/tests/throttle.test.js
new file mode 100644
index 0000000..2b74b3b
--- /dev/null
+++ b/tests/throttle.test.js
@@ -0,0 +1,101 @@
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+const Throttle = require('../lib/throttle');
+
+describe('Throttle', () => {
+ it('unlimited mode (0) returns immediately', async () => {
+ const t = new Throttle(0);
+ const start = Date.now();
+ await t.consume(10_000_000);
+ assert.ok(Date.now() - start < 50, 'should be instant');
+ });
+
+ it('unlimited with falsy values', async () => {
+ for (const val of [undefined, null, false, 0]) {
+ const t = new Throttle(val);
+ const start = Date.now();
+ await t.consume(1_000_000);
+ assert.ok(Date.now() - start < 50, `should be instant for ${val}`);
+ }
+ });
+
+ it('small consume within initial token budget resolves immediately', async () => {
+ const t = new Throttle(1024 * 1024); // 1 MB/s
+ const start = Date.now();
+ await t.consume(100); // 100 bytes, well within 1MB budget
+ assert.ok(Date.now() - start < 50);
+ });
+
+ it('large consume exceeding tokens introduces delay', async () => {
+ const t = new Throttle(1000); // 1000 bytes/sec
+ // Drain initial tokens
+ await t.consume(1000);
+
+ const start = Date.now();
+ await t.consume(500); // needs ~500ms of refill
+ const elapsed = Date.now() - start;
+ assert.ok(elapsed >= 400, `expected >=400ms, got ${elapsed}ms`);
+ assert.ok(elapsed < 2000, `expected <2000ms, got ${elapsed}ms`);
+ });
+
+ it('aborted signal stops consumption early', async () => {
+ const t = new Throttle(100); // 100 bytes/sec
+ await t.consume(100); // drain budget
+
+ const ac = new AbortController();
+ setTimeout(() => ac.abort(), 100);
+
+ const start = Date.now();
+ await t.consume(10000, ac.signal); // would take ~100s without abort
+ const elapsed = Date.now() - start;
+ assert.ok(elapsed < 1000, `should abort quickly, took ${elapsed}ms`);
+ });
+
+ it('updateRate changes behavior', async () => {
+ const t = new Throttle(100);
+ await t.consume(100); // drain
+
+ t.updateRate(0); // switch to unlimited
+ const start = Date.now();
+ await t.consume(999999);
+ assert.ok(Date.now() - start < 50, 'should be instant after switching to unlimited');
+ });
+
+ it('_refill does not exceed maxBps', () => {
+ const t = new Throttle(1000);
+ t.tokens = 0;
+ t.lastRefill = Date.now() - 60000; // simulate 60 seconds elapsed
+ t._refill();
+ assert.ok(t.tokens <= 1000, `tokens should not exceed maxBps, got ${t.tokens}`);
+ });
+
+ it('concurrent consume calls share the token pool', async () => {
+ const t = new Throttle(2000); // 2000 bytes/sec, initial tokens = 2000
+
+ // Two concurrent consumes of 1000 each - should both fit in initial budget
+ const start = Date.now();
+ await Promise.all([t.consume(1000), t.consume(1000)]);
+ assert.ok(Date.now() - start < 100, 'both should resolve from initial budget');
+
+ // Third consume should need to wait for refill
+ const start2 = Date.now();
+ await t.consume(500);
+ const elapsed = Date.now() - start2;
+ assert.ok(elapsed >= 150, `third consume should wait for refill, took ${elapsed}ms`);
+ });
+
+ it('consume(0) resolves immediately', async () => {
+ const t = new Throttle(100);
+ const start = Date.now();
+ await t.consume(0);
+ assert.ok(Date.now() - start < 50);
+ });
+
+ it('updateRate to unlimited (0) makes consume instant', async () => {
+ const t = new Throttle(100); // very slow
+ t.updateRate(0); // unlimited
+ const start = Date.now();
+ await t.consume(1_000_000);
+ assert.ok(Date.now() - start < 50, 'unlimited rate should be instant');
+ });
+});
diff --git a/tests/throttled-cache.test.js b/tests/throttled-cache.test.js
new file mode 100644
index 0000000..7037c52
--- /dev/null
+++ b/tests/throttled-cache.test.js
@@ -0,0 +1,113 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+
+const { makeThrottledCache } = require('../lib/throttled-cache');
+
+function fakeClock(start = 0) {
+ let t = start;
+ const fn = () => t;
+ fn.advance = (ms) => { t += ms; };
+ fn.set = (ms) => { t = ms; };
+ return fn;
+}
+
+test('returns undefined when empty', () => {
+ const c = makeThrottledCache(100);
+ assert.equal(c.get('any', {}), undefined);
+});
+
+test('returns the set value within the window', () => {
+ const clock = fakeClock();
+ const c = makeThrottledCache(100, clock);
+ const input = [1, 2, 3];
+ c.set('sig-a', input, 'value-1');
+ assert.equal(c.get('sig-a', input), 'value-1');
+ clock.advance(50);
+ assert.equal(c.get('sig-a', input), 'value-1', 'still valid at 50/100 ms');
+ clock.advance(49);
+ assert.equal(c.get('sig-a', input), 'value-1', 'still valid at 99/100 ms');
+});
+
+test('expires exactly at refreshMs boundary', () => {
+ const clock = fakeClock();
+ const c = makeThrottledCache(100, clock);
+ c.set('s', {}, 'v');
+ clock.advance(100);
+ assert.equal(c.get('s', {}), undefined, '>= refreshMs is a miss');
+});
+
+test('miss on different signature', () => {
+ const c = makeThrottledCache(1000, fakeClock());
+ const input = {};
+ c.set('sig-a', input, 'v');
+ assert.equal(c.get('sig-b', input), undefined);
+});
+
+test('miss on different input identity even with same signature', () => {
+ const c = makeThrottledCache(1000, fakeClock());
+ c.set('sig-a', { a: 1 }, 'v');
+ // Different object identity — the cache compares by ===, not by contents
+ assert.equal(c.get('sig-a', { a: 1 }), undefined);
+});
+
+test('overwrite by re-setting same signature', () => {
+ const clock = fakeClock();
+ const c = makeThrottledCache(100, clock);
+ const input = [];
+ c.set('s', input, 'old');
+ clock.advance(50);
+ c.set('s', input, 'new');
+ // The new entry has a fresh timestamp → still valid for another 100 ms
+ clock.advance(99);
+ assert.equal(c.get('s', input), 'new');
+});
+
+test('clear empties the cache', () => {
+ const c = makeThrottledCache(1000, fakeClock());
+ c.set('s', {}, 'v');
+ c.clear();
+ assert.equal(c.get('s', {}), undefined);
+ assert.equal(c.peek(), null);
+});
+
+test('peek reports age and signature', () => {
+ const clock = fakeClock();
+ const c = makeThrottledCache(1000, clock);
+ c.set('mysig', {}, 'v');
+ clock.advance(42);
+ const p = c.peek();
+ assert.equal(p.sig, 'mysig');
+ assert.equal(p.age, 42);
+ assert.equal(p.ts, 0);
+});
+
+test('throws on invalid refreshMs', () => {
+ assert.throws(() => makeThrottledCache(-1));
+ assert.throws(() => makeThrottledCache(NaN));
+ assert.throws(() => makeThrottledCache('100'));
+});
+
+test('refreshMs=0 means every call misses', () => {
+ const clock = fakeClock();
+ const c = makeThrottledCache(0, clock);
+ const input = {};
+ c.set('s', input, 'v');
+ // Same tick: 0 - 0 = 0 → not less than refreshMs (0) → miss
+ assert.equal(c.get('s', input), undefined);
+});
+
+test('default clock is Date.now when none provided', () => {
+ const c = makeThrottledCache(10000);
+ const input = {}; // single ref — get and set must use the SAME identity
+ c.set('x', input, 'v');
+ assert.equal(c.get('x', input), 'v');
+});
+
+test('large input arrays are tracked by identity, not value', () => {
+ const c = makeThrottledCache(1000, fakeClock());
+ const arr1 = new Array(10000).fill(0);
+ const arr2 = new Array(10000).fill(0);
+ c.set('s', arr1, 'cached');
+ assert.equal(c.get('s', arr1), 'cached');
+ assert.equal(c.get('s', arr2), undefined, 'different array → miss');
+});
diff --git a/tests/ui-smoke.js b/tests/ui-smoke.js
new file mode 100644
index 0000000..125a6d7
--- /dev/null
+++ b/tests/ui-smoke.js
@@ -0,0 +1,1288 @@
+/**
+ * UI smoke test - launches the real app and checks DOM elements via webContents.
+ * Run with: node tests/ui-smoke.js
+ * (This spawns Electron as a child process)
+ */
+if (!process.env.RUN_UI_SMOKE) {
+ const { test } = require('node:test');
+ test('ui smoke skipped unless RUN_UI_SMOKE=1', () => {});
+ return;
+}
+
+const { execFileSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const uiRunId = `${process.pid}-${Date.now()}`;
+const visualScreenshotDir = process.env.MHU_UI_SCREENSHOT_DIR
+ ? path.resolve(process.env.MHU_UI_SCREENSHOT_DIR)
+ : '';
+const injectPath = path.join(__dirname, `_ui-inject.${uiRunId}.tmp.js`);
+const userDataPath = path.join(os.tmpdir(), `mhu-ui-smoke-${uiRunId}`);
+
+if (visualScreenshotDir) fs.mkdirSync(visualScreenshotDir, { recursive: true });
+
+// Create a temp script that the real Electron app will execute via --eval
+const testScript = `
+const { app, BrowserWindow, ipcMain, dialog } = require('electron');
+const fs = require('fs');
+const net = require('net');
+const path = require('path');
+const ConfigStore = require(path.join(process.cwd(), 'lib', 'config-store'));
+const updaterModule = require(path.join(process.cwd(), 'lib', 'updater'));
+let preparedUpdateMockCalls = 0;
+let launchedUpdateMockCalls = 0;
+updaterModule.checkForUpdate = async () => ({ available: false });
+updaterModule.prepareUpdate = async (onProgress) => {
+ preparedUpdateMockCalls++;
+ if (onProgress) onProgress({ stage: 'prepared', percent: 100 });
+ return { installerPath: path.join(app.getPath('temp'), 'mhu-ui-update-' + preparedUpdateMockCalls + '.exe') };
+};
+updaterModule.launchPreparedUpdate = () => {
+ launchedUpdateMockCalls++;
+ return true;
+};
+const initialIpcHandlers = new Map();
+const registerIpcHandler = ipcMain.handle.bind(ipcMain);
+ipcMain.handle = (channel, listener) => {
+ if (!initialIpcHandlers.has(channel)) initialIpcHandlers.set(channel, listener);
+ return registerIpcHandler(channel, listener);
+};
+function restoreInitialIpcHandler(channel) {
+ ipcMain.removeHandler(channel);
+ const listener = initialIpcHandlers.get(channel);
+ if (listener) registerIpcHandler(channel, listener);
+}
+const originalAtomicWrite = ConfigStore.prototype._atomicWrite;
+const originalHistoryAtomicWrite = ConfigStore.prototype._writeHistoryFileAtomic;
+let activeConfigStore = null;
+let blockedWriteMarker = '';
+let blockedWriteStarted = false;
+let releaseBlockedWrite = null;
+let blockedHistoryWriteMarker = '';
+let blockedHistoryWriteStarted = false;
+let releaseBlockedHistoryWrite = null;
+ConfigStore.prototype._atomicWrite = function (data) {
+ activeConfigStore = this;
+ if (blockedWriteMarker && !blockedWriteStarted && String(data).includes(blockedWriteMarker)) {
+ blockedWriteStarted = true;
+ return new Promise((resolve, reject) => {
+ releaseBlockedWrite = () => originalAtomicWrite.call(this, data).then(resolve, reject);
+ });
+ }
+ return originalAtomicWrite.call(this, data);
+};
+ConfigStore.prototype._writeHistoryFileAtomic = function (history) {
+ activeConfigStore = this;
+ if (blockedHistoryWriteMarker && !blockedHistoryWriteStarted && JSON.stringify(history).includes(blockedHistoryWriteMarker)) {
+ blockedHistoryWriteStarted = true;
+ return new Promise((resolve, reject) => {
+ releaseBlockedHistoryWrite = () => originalHistoryAtomicWrite.call(this, history).then(resolve, reject);
+ });
+ }
+ return originalHistoryAtomicWrite.call(this, history);
+};
+
+// Monkey-patch: after the real window loads, run tests
+const origReady = app.whenReady;
+
+async function runAfterDelay(win, delayMs) {
+ await new Promise(r => setTimeout(r, delayMs));
+ return win;
+}
+
+async function waitUntil(read, timeoutMs = 3000) {
+ const deadline = Date.now() + timeoutMs;
+ while (Date.now() < deadline) {
+ const value = await read();
+ if (value) return value;
+ await new Promise(resolve => setTimeout(resolve, 10));
+ }
+ return null;
+}
+
+// Wait for app to be ready, then wait for the real window to load
+setTimeout(async () => {
+ const windows = BrowserWindow.getAllWindows();
+ if (windows.length === 0) { console.log('ERROR: No windows found'); process.exit(1); }
+ const win = windows[0];
+ const wc = win.webContents;
+ const originalBounds = win.getBounds();
+ const visualScreenshotDir = ${JSON.stringify(visualScreenshotDir)};
+
+ async function captureVisual(name) {
+ if (!visualScreenshotDir) return;
+ await new Promise(resolve => setTimeout(resolve, 150));
+ const screenshot = await wc.capturePage();
+ fs.writeFileSync(path.join(visualScreenshotDir, name), screenshot.toPNG());
+ }
+
+ // Wait for renderer init
+ await new Promise(r => setTimeout(r, 2000));
+
+ let passed = 0;
+ let failed = 0;
+ const results = [];
+ let realAppQuit = null;
+ let relaunchCalls = 0;
+
+ function check(name, condition) {
+ if (condition) { passed++; results.push(' PASS: ' + name); }
+ else { failed++; results.push(' FAIL: ' + name); }
+ }
+
+ try {
+ await wc.executeJavaScript('queueJobs = []; selectedFiles = []; selectedJobIds.clear(); rebuildJobIndex(); setUploadSidebarFilter("all"); updateUploadView(); renderQueueTable(); updateStatusBar();');
+ console.log('\\n=== Upload View ===');
+
+ const tabCount = await wc.executeJavaScript('document.querySelectorAll(".tab").length');
+ check('4 tabs exist', tabCount === 4);
+
+ const appHeaderExists = await wc.executeJavaScript('Boolean(document.querySelector(".app-header"))');
+ check('App shell exposes the primary header', appHeaderExists);
+
+ const appBrandText = await wc.executeJavaScript('document.querySelector(".app-brand-name")?.textContent?.trim()');
+ check('App header shows the Multi-Hoster Upload brand', appBrandText === 'MULTI-HOSTER UPLOAD');
+
+ const topbarIconCount = await wc.executeJavaScript('document.querySelectorAll(".app-header .tab .top-nav-icon").length');
+ check('App header exposes exactly four topbar icons', topbarIconCount === 4);
+
+ const headerUpdateButtonExists = await wc.executeJavaScript('Boolean(document.getElementById("headerUpdateBtn"))');
+ check('App header exposes the update action', headerUpdateButtonExists);
+
+ const initialUpdateLabel = await wc.executeJavaScript('document.querySelector("#headerUpdateBtn .header-update-label")?.textContent?.trim()');
+ check('App header uses the compact update label', initialUpdateLabel === 'Update');
+
+ const bodyBackground = await wc.executeJavaScript('getComputedStyle(document.body).backgroundColor');
+ check('App shell uses the dark reference canvas', bodyBackground === 'rgb(15, 15, 15)');
+
+ const shellDensity = await wc.executeJavaScript('(() => ({ header: document.querySelector(".app-header")?.getBoundingClientRect().height, status: document.getElementById("statusbar")?.getBoundingClientRect().height, sidebar: document.querySelector("#upload-view > .view-sidebar")?.getBoundingClientRect().width }))()');
+ check('App shell keeps a compact desktop density', shellDensity.header <= 50 && shellDensity.status <= 30 && shellDensity.sidebar <= 230);
+
+ const tabLabels = await wc.executeJavaScript('[...document.querySelectorAll(".tab")].map(el => el.textContent.trim()).join("|")');
+ check('Current tab labels present', tabLabels === 'Upload|Accounts|Einstellungen|Verlauf');
+
+ const tabSemantics = await wc.executeJavaScript('document.querySelector(".tab-bar")?.getAttribute("role") + "|" + document.querySelector(".tab.active")?.getAttribute("aria-selected")');
+ check('Tab navigation exposes active state', tabSemantics === 'tablist|true');
+
+ const activeTab = await wc.executeJavaScript('document.querySelector(".tab.active")?.textContent?.trim()');
+ check('Upload tab active by default', activeTab === 'Upload');
+
+ const tabStops = await wc.executeJavaScript('[...document.querySelectorAll(".tab")].map(el => el.tabIndex).join("|")');
+ check('Tab navigation exposes one keyboard stop', tabStops === '0|-1|-1|-1');
+
+ const dropVisible = await wc.executeJavaScript('document.getElementById("dropZone")?.style.display !== "none"');
+ check('Drop zone visible (no files)', dropVisible);
+
+ const queueHidden = await wc.executeJavaScript('document.getElementById("queueShell")?.style.display');
+ check('Queue hidden (no files)', queueHidden === 'none');
+
+ const startDisabled = await wc.executeJavaScript('document.getElementById("startUploadBtn")?.disabled');
+ check('Start button disabled initially', startDisabled === true);
+
+ const sbState = await wc.executeJavaScript('document.getElementById("sbState")?.textContent');
+ check('Statusbar: Bereit', sbState === 'Bereit');
+
+ const version = await wc.executeJavaScript('document.getElementById("versionLabel")?.textContent');
+ check('Version label present', version && version.startsWith('v'));
+
+ const localizedQueueHeaders = await wc.executeJavaScript('[...document.querySelectorAll("#queueTable thead th")].map(el => el.childNodes[0]?.textContent.trim()).join("|")');
+ check('Upload table labels are consistently German', localizedQueueHeaders === 'Dateiname|Hochgeladen / Größe|Hoster|Status|Zeit|Rest|Geschwindigkeit|Fortschritt');
+
+ const localizedRecentTabs = await wc.executeJavaScript('[...document.querySelectorAll(".recent-tab")].map(el => el.textContent.trim()).join("|")');
+ check('Recent panel labels are consistently German', localizedRecentTabs === 'Dateien|Statistik');
+
+ const localizedStatusbar = await wc.executeJavaScript('["sbConnections", "sbQueueCount", "sbRemainingCount", "sbInProgressCount", "sbDoneCount", "sbErrorCount"].map(id => document.getElementById(id)?.textContent).join("|")');
+ check('Statusbar labels are consistently German', localizedStatusbar === 'Verbindungen 0|Gesamt 0|Verbleibend 0|Läuft 0|Fertig 0|Fehler 0');
+
+ const toolbarLabels = await wc.executeJavaScript('[...document.querySelectorAll("#queueCommandBar .toolbar-btn")].map(el => el.getAttribute("aria-label")).join("|")');
+ check('Upload toolbar actions have German accessible names', toolbarLabels === 'Alle Uploads starten|Ausgewählte Uploads starten|Ausgewählte Datei erneut hochladen|Ausgewählten Upload abbrechen|Aktive Uploads beenden und stoppen|Alle Uploads abbrechen|Ganz nach oben|Nach oben|Nach unten|Ganz nach unten');
+
+ const uploadWorkspaceLayout = await wc.executeJavaScript('(() => { const view = document.getElementById("upload-view"); const sidebar = view?.querySelector(":scope > .view-sidebar"); const main = view?.querySelector(":scope > .view-main"); if (!sidebar || !main) return false; const sidebarRect = sidebar.getBoundingClientRect(); const mainRect = main.getBoundingClientRect(); return sidebarRect.width > 0 && mainRect.width > 0 && sidebarRect.right <= mainRect.left; })()');
+ check('Upload view separates sidebar and main workspace', uploadWorkspaceLayout === true);
+
+ const uploadSidebarInformation = await wc.executeJavaScript('(() => { const sidebar = document.querySelector("#upload-view > .view-sidebar")?.getBoundingClientRect(); const section = document.querySelector("#upload-view .view-sidebar-section")?.getBoundingClientRect(); return Boolean(sidebar && section && section.top >= sidebar.top + sidebar.height * 0.55 && document.getElementById("uploadSidebarAccountsCount")); })()');
+ check('Upload sidebar keeps availability information in its lower area', uploadSidebarInformation === true);
+
+ const uploadFrameFit = await wc.executeJavaScript('(() => { const view = document.getElementById("upload-view")?.getBoundingClientRect(); const status = document.getElementById("statusbar")?.getBoundingClientRect(); return Boolean(view && status && status.height > 0 && view.bottom <= status.top + 1 && status.bottom <= window.innerHeight + 1); })()');
+ check('Upload view and statusbar fit inside the viewport', uploadFrameFit === true);
+
+ await captureVisual('01-upload.png');
+
+ const uploadFilterState = await wc.executeJavaScript(\`(() => {
+ const makeJob = (id, fileName, status) => ({ id, file: 'C:/ui/' + fileName, fileName, hoster: 'byse.sx', status, bytesUploaded: 0, bytesTotal: 1024, speedKbs: 0, elapsed: 0, remaining: 0, progress: status === 'done' ? 1 : 0 });
+ const waiting = Array.from({ length: 201 }, (_, index) => makeJob('ui-wait-' + index, 'wait-' + String(index).padStart(3, '0') + '.bin', 'queued'));
+ queueJobs = [makeJob('ui-active-z', 'active-z.bin', 'uploading'), ...waiting, makeJob('ui-error', 'error.bin', 'error'), makeJob('ui-done', 'done.bin', 'done'), makeJob('ui-active-a', 'active-a.bin', 'retrying')];
+ queueSortState.key = 'filename';
+ queueSortState.direction = 'asc';
+ selectedJobIds.clear();
+ selectedJobIds.add('ui-active-z');
+ selectedJobIds.add('ui-error');
+ const sourceOrder = queueJobs.map(job => job.id).join(',');
+ document.getElementById('queueContainer').scrollTop = 0;
+ renderQueueTable();
+ const allState = {
+ working: _sortedJobsCache.length,
+ rendered: document.querySelectorAll('#queueBody .queue-row').length,
+ spacer: Boolean(document.querySelector('#queueBody .virtual-spacer')),
+ height: document.querySelector('#queueBody .queue-row')?.style.height
+ };
+ const inspect = (value) => {
+ document.querySelector('[data-upload-sidebar-target="' + value + '"]').click();
+ return {
+ working: _sortedJobsCache.length,
+ ids: [...document.querySelectorAll('#queueBody .queue-row')].map(row => row.dataset.jobId),
+ names: [...document.querySelectorAll('#queueBody .queue-row .col-filename')].map(cell => cell.textContent),
+ spacer: Boolean(document.querySelector('#queueBody .virtual-spacer')),
+ selected: [...selectedJobIds],
+ pressed: [...document.querySelectorAll('[data-upload-sidebar-target]')].filter(button => button.getAttribute('aria-pressed') === 'true').map(button => button.dataset.uploadSidebarTarget),
+ active: [...document.querySelectorAll('[data-upload-sidebar-target].active')].map(button => button.dataset.uploadSidebarTarget)
+ };
+ };
+ const active = inspect('active');
+ const waitingState = inspect('waiting');
+ const done = inspect('done');
+ const error = inspect('error');
+ const restored = inspect('all');
+ const sourceUnchanged = sourceOrder === queueJobs.map(job => job.id).join(',');
+ queueJobs = [makeJob('ui-only-waiting', 'only-waiting.bin', 'queued')];
+ const emptyError = inspect('error');
+ const emptySafe = queueJobs.length === 1 && emptyError.working === 0 && emptyError.ids.length === 0;
+ queueJobs = [];
+ document.querySelector('[data-upload-sidebar-target="all"]').click();
+ updateStatusBar();
+ return { allState, active, waitingState, done, error, restored, sourceUnchanged, emptySafe };
+ })()\`);
+ check('Upload sidebar filters the visible queue without mutating source order', uploadFilterState.active.working === 2 && uploadFilterState.active.names.join('|') === 'active-a.bin|active-z.bin' && uploadFilterState.waitingState.working === 201 && uploadFilterState.done.ids.join('|') === 'ui-done' && uploadFilterState.error.ids.join('|') === 'ui-error' && uploadFilterState.restored.working === 205 && uploadFilterState.sourceUnchanged);
+ check('Upload sidebar retains 28px virtual rows for large filtered queues', uploadFilterState.allState.working === 205 && uploadFilterState.allState.rendered > 0 && uploadFilterState.allState.rendered < 205 && uploadFilterState.allState.spacer && uploadFilterState.allState.height === '28px' && uploadFilterState.waitingState.spacer);
+ check('Upload sidebar exposes one pressed filter and handles empty matches', uploadFilterState.active.pressed.join('|') === 'active' && uploadFilterState.active.active.join('|') === 'active' && uploadFilterState.error.pressed.join('|') === 'error' && uploadFilterState.error.active.join('|') === 'error' && uploadFilterState.emptySafe);
+ check('Upload sidebar drops hidden selections when changing filters', uploadFilterState.active.selected.join('|') === 'ui-active-z');
+
+ const uploadSelectionScope = await wc.executeJavaScript(\`(() => {
+ const makeJob = (id, status) => ({ id, file: 'C:/ui/' + id + '.bin', fileName: id + '.bin', hoster: 'byse.sx', status, bytesUploaded: 0, bytesTotal: 1024, speedKbs: 0, elapsed: 0, remaining: 0, progress: status === 'done' ? 1 : 0 });
+ const activeA = makeJob('scope-active-a', 'uploading');
+ const activeZ = makeJob('scope-active-z', 'retrying');
+ const error = makeJob('scope-error', 'error');
+ const done = makeJob('scope-done', 'done');
+ queueJobs = [activeZ, error, done, activeA];
+ rebuildJobIndex();
+ selectedJobIds.clear();
+ selectedRecentIds.clear();
+ setUploadSidebarFilter('active');
+ document.getElementById('queueContainer').dispatchEvent(new KeyboardEvent('keydown', { key: 'a', ctrlKey: true, bubbles: true }));
+ const ctrlASelected = [...selectedJobIds].sort();
+ selectedJobIds.clear();
+ selectedJobIds.add(activeA.id);
+ activeA.status = 'done';
+ renderQueueTable();
+ const statusChangeSelected = [...selectedJobIds];
+ const statusChangeVisible = _sortedJobsCache.map(job => job.id);
+ queueJobs = [activeZ, error, done, activeA];
+ activeA.status = 'uploading';
+ rebuildJobIndex();
+ setUploadSidebarFilter('active');
+ selectedJobIds.clear();
+ selectedJobIds.add(error.id);
+ updateQueueActionButtons();
+ const hiddenAction = {
+ selected: [...selectedJobIds],
+ retryDisabled: document.getElementById('reuploadSelectedBtn').disabled,
+ moveDisabled: document.getElementById('moveTopBtn').disabled
+ };
+ queueJobs = [];
+ selectedJobIds.clear();
+ rebuildJobIndex();
+ setUploadSidebarFilter('all');
+ updateStatusBar();
+ return { ctrlASelected, statusChangeSelected, statusChangeVisible, hiddenAction };
+ })()\`);
+ check('Ctrl+A selects only jobs visible in the upload filter', uploadSelectionScope.ctrlASelected.join('|') === 'scope-active-a|scope-active-z');
+ check('Status changes drop selections that leave the upload filter', uploadSelectionScope.statusChangeSelected.length === 0 && uploadSelectionScope.statusChangeVisible.join('|') === 'scope-active-z');
+ check('Selected upload actions ignore hidden stale selections', uploadSelectionScope.hiddenAction.selected.length === 0 && uploadSelectionScope.hiddenAction.retryDisabled && uploadSelectionScope.hiddenAction.moveDisabled);
+
+ const keyboardTab = await wc.executeJavaScript('document.getElementById("upload-tab").focus(); document.getElementById("upload-tab").dispatchEvent(new KeyboardEvent("keydown", { key: "ArrowRight", bubbles: true })); document.querySelector(".tab.active")?.textContent?.trim() + "|" + document.activeElement?.id');
+ check('Arrow keys move and activate main tabs', keyboardTab === 'Accounts|accounts-tab');
+
+ const ctxHidden = await wc.executeJavaScript('document.getElementById("contextMenu")?.style.display');
+ check('Context menu hidden', ctxHidden === 'none');
+
+ console.log('\\n=== Accounts View ===');
+
+ await wc.executeJavaScript('document.querySelector(".tab[data-view=\\'accounts\\']").click()');
+ await new Promise(r => setTimeout(r, 300));
+
+ const accountsActive = await wc.executeJavaScript('document.getElementById("accounts-view")?.classList.contains("active")');
+ check('Accounts tab active', accountsActive);
+
+ const accountsWorkspaceLayout = await wc.executeJavaScript('(() => { const view = document.getElementById("accounts-view"); const sidebar = view?.querySelector(":scope > .view-sidebar"); const main = view?.querySelector(":scope > .view-main"); if (!sidebar || !main) return false; const sidebarRect = sidebar.getBoundingClientRect(); const mainRect = main.getBoundingClientRect(); return sidebarRect.width > 0 && mainRect.width > 0 && sidebarRect.right <= mainRect.left; })()');
+ check('Accounts view separates sidebar and main workspace', accountsWorkspaceLayout === true);
+
+ const accountSidebarInformation = await wc.executeJavaScript('(() => { const sidebar = document.querySelector("#accounts-view > .view-sidebar")?.getBoundingClientRect(); const section = document.querySelector("#accounts-view .view-sidebar-hoster-section")?.getBoundingClientRect(); return Boolean(sidebar && section && section.top >= sidebar.top + sidebar.height * 0.55); })()');
+ check('Account sidebar keeps hoster information in its lower area', accountSidebarInformation === true);
+
+ const accountsFrameFit = await wc.executeJavaScript('(() => { const view = document.getElementById("accounts-view")?.getBoundingClientRect(); const status = document.getElementById("statusbar")?.getBoundingClientRect(); return Boolean(view && status && status.height > 0 && view.bottom <= status.top + 1 && status.bottom <= window.innerHeight + 1); })()');
+ check('Accounts view and statusbar fit inside the viewport', accountsFrameFit === true);
+
+ await captureVisual('02-accounts.png');
+
+ const accountListValid = await wc.executeJavaScript('Boolean(document.querySelector("#accountsList .accounts-empty") || document.querySelectorAll("#accountsList .account-hoster-group").length)');
+ check('Account manager list structure rendered', accountListValid);
+
+ const addAccountEnabled = await wc.executeJavaScript('document.getElementById("addAccountBtn")?.disabled === false');
+ check('Add account button enabled', addAccountEnabled);
+
+ const emptyAccountAction = await wc.executeJavaScript('document.querySelector("[data-account-empty-add]")?.textContent?.trim() || document.getElementById("addAccountBtn")?.textContent?.trim()');
+ check('Account list offers direct add action', emptyAccountAction === 'Ersten Account hinzufügen' || emptyAccountAction === 'Account hinzufügen');
+
+ const accountEmptyStateActionCount = await wc.executeJavaScript('document.querySelectorAll("#accountsList [data-account-empty-add]").length');
+ check('Account empty state avoids a duplicate primary action', accountEmptyStateActionCount === 0);
+
+ await wc.executeJavaScript('(() => { const trigger = document.querySelector("[data-account-empty-add]") || document.getElementById("addAccountBtn"); trigger?.focus(); trigger?.click(); })()');
+ await new Promise(r => setTimeout(r, 200));
+
+ const accountModalVisible = await wc.executeJavaScript('document.getElementById("accountModal")?.style.display');
+ check('Account modal opens', accountModalVisible === 'flex');
+
+ const accountModalTitle = await wc.executeJavaScript('document.getElementById("accountModalTitle")?.textContent');
+ check('Account modal is in add mode', accountModalTitle === 'Account hinzufügen');
+
+ const accountModalSemantics = await wc.executeJavaScript('document.querySelector("#accountModal .modal-card")?.getAttribute("role") + "|" + document.querySelector("#accountModal .modal-card")?.getAttribute("aria-modal")');
+ check('Account modal exposes dialog semantics', accountModalSemantics === 'dialog|true');
+
+ const accountFormLabels = await wc.executeJavaScript('["accountHosterSelect", "accField_label", "accField_username", "accField_password"].every(id => document.getElementById(id)?.labels?.length === 1)');
+ check('Account form controls have linked labels', accountFormLabels);
+
+ const accountStatusLive = await wc.executeJavaScript('document.getElementById("accountModalStatus")?.getAttribute("aria-live")');
+ check('Account validation status is announced', accountStatusLive === 'polite');
+
+ const initialAccountFocus = await wc.executeJavaScript('document.activeElement?.id');
+ check('Account modal focuses first control', initialAccountFocus === 'accountHosterSelect');
+
+ const trappedAccountFocus = await wc.executeJavaScript('document.getElementById("saveAccountBtn").focus(); document.dispatchEvent(new KeyboardEvent("keydown", { key: "Tab", bubbles: true })); document.activeElement?.id');
+ check('Account modal keeps keyboard focus inside', trappedAccountFocus === 'closeAccountModalBtn');
+
+ const authOptionCount = await wc.executeJavaScript('document.querySelectorAll("#accountHosterSelect option").length');
+ check('7 hoster authentication options exist', authOptionCount === 7);
+
+ const hosterCount = await wc.executeJavaScript('[...new Set([...document.querySelectorAll("#accountHosterSelect option")].map(el => el.value.split(":")[0]))].length');
+ check('5 hosters exist', hosterCount === 5);
+
+ const accountSubmitLabel = await wc.executeJavaScript('document.getElementById("saveAccountBtn")?.textContent');
+ check('Account submit label is Prüfen und speichern', accountSubmitLabel === 'Prüfen und speichern');
+
+ const credentialInputs = await wc.executeJavaScript('document.querySelectorAll("#accountCredsFields .key-input").length');
+ check('Credential inputs rendered', credentialInputs === 2);
+
+ const passwordToggleState = await wc.executeJavaScript('document.querySelector("#accountCredsFields .toggle-vis").click(); document.querySelector("#accountCredsFields .toggle-vis").getAttribute("aria-label") + "|" + document.querySelector("#accountCredsFields .toggle-vis").getAttribute("aria-pressed")');
+ check('Password visibility action exposes its state', passwordToggleState === 'Passwort verbergen|true');
+
+ await wc.executeJavaScript('document.dispatchEvent(new KeyboardEvent("keydown", { key: "Escape", bubbles: true }))');
+ const accountModalHidden = await wc.executeJavaScript('document.getElementById("accountModal")?.style.display');
+ check('Escape closes account modal', accountModalHidden === 'none');
+
+ const restoredAccountFocus = await wc.executeJavaScript('document.activeElement?.hasAttribute("data-account-empty-add") || document.activeElement?.id === "addAccountBtn"');
+ check('Account modal restores trigger focus', restoredAccountFocus === true);
+
+ const fallbackAccountFocus = await wc.executeJavaScript('(() => { const trigger = document.querySelector("[data-account-empty-add]") || document.getElementById("addAccountBtn"); trigger.focus(); trigger.click(); document.querySelector("[data-account-empty-add]")?.remove(); document.dispatchEvent(new KeyboardEvent("keydown", { key: "Escape", bubbles: true })); return document.activeElement?.id; })()');
+ check('Account modal restores stable focus after list rerender', fallbackAccountFocus === 'addAccountBtn');
+
+ const mixedGroupStatus = await wc.executeJavaScript(\`(() => {
+ config.hosters['byse.sx'] = [
+ { id: 'ui-status-ok-1', enabled: true, authType: 'api', apiKey: 'key-one' },
+ { id: 'ui-status-ok-2', enabled: true, authType: 'api', apiKey: 'key-two' },
+ { id: 'ui-status-error', enabled: true, authType: 'api', apiKey: 'key-three' }
+ ];
+ accountStatuses['ui-status-ok-1'] = { status: 'ok', message: 'Bereit' };
+ accountStatuses['ui-status-ok-2'] = { status: 'ok', message: 'Bereit' };
+ accountStatuses['ui-status-error'] = { status: 'error', message: 'Deaktiviert durch Administrator' };
+ renderAccounts();
+ const dot = document.querySelector('.account-hoster-group[data-hoster-group="byse.sx"] .account-hoster-group-header .account-status-dot');
+ return [dot?.className, getComputedStyle(dot).backgroundColor].join('|');
+ })()\`);
+ check('Mixed account results use orange group status', mixedGroupStatus === 'account-status-dot status-warn|rgb(240, 195, 108)');
+
+ const allErrorGroupStatus = await wc.executeJavaScript(\`(() => {
+ accountStatuses['ui-status-ok-1'] = { status: 'error', message: 'Fehler' };
+ accountStatuses['ui-status-ok-2'] = { status: 'error', message: 'Fehler' };
+ renderAccounts();
+ return document.querySelector('.account-hoster-group[data-hoster-group="byse.sx"] .account-hoster-group-header .account-status-dot')?.className;
+ })()\`);
+ check('All-error account group uses red status', allErrorGroupStatus === 'account-status-dot status-error');
+
+ const otpCardState = await wc.executeJavaScript(\`(() => {
+ config.hosters['doodstream.com'] = [{ id: 'ui-status-otp', enabled: true, authType: 'login', username: 'otp@example.com', password: 'password' }];
+ accountStatuses['ui-status-otp'] = { status: 'otp_required', message: 'OTP wurde an deine E-Mail gesendet.' };
+ renderAccounts();
+ const card = [...document.querySelectorAll('.account-card')].find(el => el.dataset.accountId === 'ui-status-otp');
+ return [
+ card?.querySelector('[data-account-otp-input]')?.getAttribute('placeholder'),
+ card?.querySelector('[data-account-otp-submit]')?.textContent?.trim(),
+ card?.querySelector('.account-status')?.textContent?.trim()
+ ].join('|');
+ })()\`);
+ check('OTP-required account exposes inline code input and save action', otpCardState === 'Code aus E-Mail|Prüfen und speichern|OTP erforderlich');
+
+ const otpSubmitState = await wc.executeJavaScript(\`(() => {
+ const card = [...document.querySelectorAll('.account-card')].find(el => el.dataset.accountId === 'ui-status-otp');
+ card.querySelector('[data-account-otp-input]').value = '123456';
+ card.querySelector('[data-account-otp-submit]').click();
+ return [accountStatuses['ui-status-otp']?.status, String(card.querySelector('[data-account-otp-submit]')?.disabled)].join('|');
+ })()\`);
+ check('Inline OTP submission starts validation', otpSubmitState === 'checking|true');
+
+ const accountFilterState = await wc.executeJavaScript(\`(() => {
+ HOSTERS.forEach(name => { config.hosters[name] = []; });
+ config.hosters['doodstream.com'] = [
+ { id: 'ui-filter-no-creds', enabled: true, authType: 'login', username: '', password: '' }
+ ];
+ config.hosters['byse.sx'] = [
+ { id: 'ui-filter-ready', enabled: true, authType: 'api', apiKey: 'ready-key' },
+ { id: 'ui-filter-disabled', enabled: false, authType: 'api', apiKey: 'disabled-key' },
+ { id: 'ui-filter-error', enabled: true, authType: 'api', apiKey: 'error-key' }
+ ];
+ accountStatuses = {
+ 'ui-filter-no-creds': { status: 'ok', message: 'Bereit' },
+ 'ui-filter-ready': { status: 'ok', message: 'Bereit' },
+ 'ui-filter-disabled': { status: 'ok', message: 'Bereit' },
+ 'ui-filter-error': { status: 'error', message: 'Fehler' }
+ };
+ renderAccounts();
+ const inspect = (value) => {
+ document.querySelector('[data-accounts-sidebar-filter="' + value + '"]').click();
+ return {
+ cards: [...document.querySelectorAll('#accountsList .account-card')].filter(card => !card.hidden).map(card => card.dataset.accountId).sort(),
+ groups: [...document.querySelectorAll('#accountsList .account-hoster-group')].filter(group => !group.hidden).map(group => group.dataset.hosterGroup).sort(),
+ pressed: [...document.querySelectorAll('[data-accounts-sidebar-filter]')].filter(button => button.getAttribute('aria-pressed') === 'true').map(button => button.dataset.accountsSidebarFilter),
+ active: [...document.querySelectorAll('[data-accounts-sidebar-filter].active')].map(button => button.dataset.accountsSidebarFilter)
+ };
+ };
+ const ready = inspect('ready');
+ const warning = inspect('warning');
+ const error = inspect('error');
+ const all = inspect('all');
+ const counters = ['accountsSidebarAllCount', 'accountsSidebarReadyCount', 'accountsSidebarWarningCount', 'accountsSidebarErrorCount'].map(id => document.getElementById(id)?.textContent);
+ return { ready, warning, error, all, counters };
+ })()\`);
+ check('Account sidebar filters cards and hides hoster groups without matches', accountFilterState.ready.cards.join('|') === 'ui-filter-ready' && accountFilterState.ready.groups.join('|') === 'byse.sx' && accountFilterState.warning.cards.join('|') === 'ui-filter-disabled|ui-filter-no-creds' && accountFilterState.warning.groups.join('|') === 'byse.sx|doodstream.com' && accountFilterState.error.cards.join('|') === 'ui-filter-error' && accountFilterState.error.groups.join('|') === 'byse.sx' && accountFilterState.all.cards.length === 4);
+ check('Account sidebar classifies disabled and credential-less accounts as action needed', accountFilterState.counters.join('|') === '4|1|2|1');
+ check('Account sidebar exposes exactly one pressed filter', accountFilterState.error.pressed.join('|') === 'error' && accountFilterState.error.active.join('|') === 'error' && accountFilterState.all.pressed.join('|') === 'all' && accountFilterState.all.active.join('|') === 'all');
+
+ console.log('\\n=== Settings View ===');
+
+ await wc.executeJavaScript('document.querySelector(".tab[data-view=\\'settings\\']").click()');
+ await new Promise(r => setTimeout(r, 300));
+
+ const settingsActive = await wc.executeJavaScript('document.getElementById("settings-view")?.classList.contains("active")');
+ check('Settings tab active', settingsActive);
+
+ let updateCheckCallCount = 0;
+ const updateCheckResolvers = [];
+ ipcMain.removeHandler('app:check-updates');
+ ipcMain.handle('app:check-updates', () => {
+ updateCheckCallCount++;
+ return new Promise(resolve => updateCheckResolvers.push(resolve));
+ });
+ await wc.executeJavaScript(\`(() => {
+ _knownUpdateInfo = null;
+ _updateCheckBusy = false;
+ closeUpdateDialog();
+ _syncHeaderUpdateState();
+ document.getElementById('manualUpdateCheckBtn').click();
+ _handleMenuAction('check-updates');
+ document.getElementById('headerUpdateBtn').click();
+ })()\`);
+ await new Promise(resolve => setTimeout(resolve, 100));
+ const coordinatedUpdateBusy = await wc.executeJavaScript('(() => { const manual = document.getElementById("manualUpdateCheckBtn"); const header = document.getElementById("headerUpdateBtn"); return [manual?.disabled, manual?.getAttribute("aria-busy"), manual?.textContent?.trim(), header?.disabled, header?.getAttribute("aria-busy")].join("|"); })()');
+ check('All update entry points share one in-flight check', updateCheckCallCount === 1 && coordinatedUpdateBusy === 'true|true|Prüfe…|true|true');
+ updateCheckResolvers.splice(0).forEach(resolve => resolve({ available: false, error: 'Simulierter Netzwerkfehler' }));
+ await new Promise(resolve => setTimeout(resolve, 150));
+ const coordinatedUpdateError = await wc.executeJavaScript('(() => { const manual = document.getElementById("manualUpdateCheckBtn"); const header = document.getElementById("headerUpdateBtn"); return [manual?.disabled, header?.disabled, manual?.textContent?.trim(), document.getElementById("copyToast")?.textContent?.trim()].join("|"); })()');
+ check('Settings update check uses the shared error contract', coordinatedUpdateError === 'false|false|Nach Updates suchen|Updateprüfung fehlgeschlagen');
+ await wc.executeJavaScript('document.getElementById("copyToast")?.classList.remove("show")');
+
+ const settingsNavigation = await wc.executeJavaScript('(() => { const buttons = [...document.querySelectorAll(".settings-nav-button")]; return [buttons.length, buttons.map(button => button.textContent.trim()).join("|"), document.querySelector(".settings-nav-button.active")?.dataset.settingsPage, document.getElementById("settingsSearchInput")?.placeholder].join("::"); })()');
+ check('Settings use the task-based sidebar navigation', settingsNavigation === '8::Allgemein|Uploads|Automatik|Benachrichtigungen|Logs & Support|Fernsteuerung|Diagnose-Zugriff|Backup & Übertragen::allgemein::Einstellungen durchsuchen');
+
+ const settingsSidebarInformation = await wc.executeJavaScript('(() => { const feedback = document.getElementById("saveFeedback"); const sidebar = document.querySelector(".settings-sidebar"); const status = document.querySelector(".settings-sidebar-status"); return Boolean(feedback && sidebar?.contains(feedback) && status && !document.querySelector(".settings-header #saveFeedback")); })()');
+ check('Settings sidebar owns the persistent save information', settingsSidebarInformation === true);
+
+ await captureVisual('03-settings.png');
+
+ await wc.executeJavaScript('document.querySelector("[data-settings-page=\\'uploads\\']")?.click()');
+ const uploadSettingsState = await wc.executeJavaScript('(() => { const activePage = document.querySelector(".settings-subpage.active"); return [activePage?.dataset.subpage, activePage?.querySelector("h3")?.textContent.trim(), document.querySelector("label[for=removeFromQueueOnDoneInput]")?.textContent.trim(), document.getElementById("removeFromQueueOnDoneInput")?.closest(".settings-option")?.querySelector(".settings-option-description")?.textContent.trim()].join("|"); })()');
+ check('Upload completion behavior is immediately findable', uploadSettingsState === 'uploads|Upload-Verhalten|Nach Abschluss aus der Liste entfernen|Erfolgreich hochgeladene Dateien verschwinden automatisch aus der Upload-Liste.');
+
+ const settingsReadingWidth = await wc.executeJavaScript('(() => { const activePage = document.querySelector(".settings-subpage.active"); if (!activePage) return 0; return activePage.getBoundingClientRect().width; })()');
+ check('Active settings page keeps a readable content width', settingsReadingWidth > 0 && settingsReadingWidth <= 640);
+
+ const settingsFrameFit = await wc.executeJavaScript('(() => { const view = document.getElementById("settings-view")?.getBoundingClientRect(); const status = document.getElementById("statusbar")?.getBoundingClientRect(); return Boolean(view && status && status.height > 0 && view.bottom <= status.top + 1 && status.bottom <= window.innerHeight + 1); })()');
+ check('Settings view and statusbar fit inside the viewport', settingsFrameFit === true);
+
+ if (process.env.MHU_SETTINGS_SCREENSHOT) {
+ const screenshotPage = process.env.MHU_SETTINGS_SCREENSHOT_PAGE;
+ if (screenshotPage) await wc.executeJavaScript('document.querySelector("[data-settings-page=" + ' + JSON.stringify(screenshotPage) + ' + "]")?.click()');
+ await new Promise(resolve => setTimeout(resolve, 150));
+ const screenshot = await wc.capturePage();
+ fs.writeFileSync(process.env.MHU_SETTINGS_SCREENSHOT, screenshot.toPNG());
+ }
+
+ const settingsSearchState = await wc.executeJavaScript('(() => { const search = document.getElementById("settingsSearchInput"); if (!search) return "missing"; search.value = "fertig"; search.dispatchEvent(new Event("input", { bubbles: true })); const visible = [...document.querySelectorAll(".settings-nav-button")].filter(button => !button.hidden); return [visible.map(button => button.dataset.settingsPage).join(","), document.querySelector(".settings-nav-button.active")?.dataset.settingsPage].join("|"); })()');
+ check('Settings search routes completion terms to Uploads first', settingsSearchState === 'uploads,benachrichtigungen|uploads');
+
+ const settingsSearchRecovery = await wc.executeJavaScript('(() => { const search = document.getElementById("settingsSearchInput"); search.value = "kein-passender-treffer"; search.dispatchEvent(new Event("input", { bubbles: true })); const emptyVisible = !document.getElementById("settingsSearchEmpty").hidden; search.value = ""; search.dispatchEvent(new Event("input", { bubbles: true })); return [emptyVisible, document.querySelector(".settings-subpage.active")?.dataset.subpage, document.getElementById("settingsSearchEmpty").hidden].join("|"); })()');
+ check('Clearing an empty settings search restores the current page', settingsSearchRecovery === 'true|uploads|true');
+
+ const filteredOnlineRestoreNavigation = await wc.executeJavaScript('(() => { const search = document.getElementById("settingsSearchInput"); search.value = "fertig"; search.dispatchEvent(new Event("input", { bubbles: true })); _handleMenuAction("online-backup-restore"); return [search.value, document.querySelector(".settings-nav-button.active")?.dataset.settingsPage, document.activeElement?.id].join("|"); })()');
+ check('Online restore navigation clears filters and opens Backup', filteredOnlineRestoreNavigation === '|backup|onlineBackupKeyInput');
+
+ const accountSettingsPointer = await wc.executeJavaScript('document.querySelector(".settings-hoster-pointer")?.textContent');
+ check('Hoster settings point to Accounts tab', accountSettingsPointer && accountSettingsPointer.includes('Accounts'));
+
+ const parallel = await wc.executeJavaScript('document.getElementById("parallelUploadCountInput")?.value');
+ check('Global parallel uploads default 0', parallel === '0');
+
+ await wc.executeJavaScript('document.querySelector("[data-settings-page=\\'backup\\']")?.click()');
+ const onlineBackupControls = await wc.executeJavaScript('["createOnlineBackupBtn", "onlineBackupKeyOutput", "copyOnlineBackupKeyBtn", "onlineBackupKeyInput", "restoreOnlineBackupBtn", "onlineBackupStatus"].every(id => Boolean(document.getElementById(id)))');
+ check('Online backup controls exist', onlineBackupControls);
+
+ const onlineBackupKeyContract = await wc.executeJavaScript('document.getElementById("onlineBackupKeyInput")?.maxLength + "|" + document.getElementById("onlineBackupKeyInput")?.getAttribute("pattern")');
+ check('Online backup input enforces the 75-character MHU key format', onlineBackupKeyContract === '75|MHU2-[A-Za-z0-9_-]{70}');
+
+ const onlineBackupBridge = await wc.executeJavaScript('typeof window.api.createOnlineBackup + "|" + typeof window.api.restoreOnlineBackup');
+ check('Online backup uses a narrow preload bridge', onlineBackupBridge === 'function|function');
+
+ const invalidOnlineBackup = await wc.executeJavaScript('document.getElementById("onlineBackupKeyInput").value = "MHU2-short"; document.getElementById("onlineBackupKeyInput").dispatchEvent(new Event("input", { bubbles: true })); document.getElementById("restoreOnlineBackupBtn").disabled + "|" + document.getElementById("onlineBackupStatus").textContent');
+ check('Invalid online backup keys stay blocked with visible guidance', invalidOnlineBackup === 'true|Der Schlüssel muss exakt 75 Zeichen lang sein.');
+
+ const validOnlineBackup = await wc.executeJavaScript('document.getElementById("onlineBackupKeyInput").value = "MHU2-" + "A".repeat(70); document.getElementById("onlineBackupKeyInput").dispatchEvent(new Event("input", { bubbles: true })); document.getElementById("restoreOnlineBackupBtn").disabled');
+ check('Valid 75-character online backup keys enable restore', validOnlineBackup === false);
+
+ const onlineRestoreNavigation = await wc.executeJavaScript('_handleMenuAction("online-backup-restore"); document.activeElement?.id + "|" + document.querySelector(".settings-nav-button.active")?.dataset.settingsPage');
+ check('Online restore menu opens the backup page and focuses the key', onlineRestoreNavigation === 'onlineBackupKeyInput|backup');
+
+ // Test save
+ await wc.executeJavaScript('document.getElementById("saveSettingsBtn").click()');
+ let feedback = '';
+ for (let attempt = 0; attempt < 50; attempt++) {
+ feedback = await wc.executeJavaScript('document.getElementById("saveFeedback")?.textContent');
+ if (feedback === 'Gespeichert!') break;
+ await new Promise(r => setTimeout(r, 50));
+ }
+ check('Save shows Gespeichert!', feedback === 'Gespeichert!');
+
+ const originalShowSaveDialog = dialog.showSaveDialog;
+ const originalShowOpenDialog = dialog.showOpenDialog;
+ const exportRacePath = path.join(app.getPath('userData'), 'ui-export-race.json');
+ dialog.showSaveDialog = async () => ({ canceled: false, filePath: exportRacePath });
+ const exportRaceConfig = await wc.executeJavaScript('window.api.getConfig()');
+ const exportRaceSettings = { ...(exportRaceConfig.globalSettings || {}), webhookUrl: 'https://export-race.invalid/current' };
+ blockedWriteMarker = 'https://export-race.invalid/current';
+ blockedWriteStarted = false;
+ releaseBlockedWrite = null;
+ const delayedExportSave = wc.executeJavaScript('window.api.saveGlobalSettings(' + JSON.stringify(exportRaceSettings) + ')');
+ for (let attempt = 0; attempt < 100 && !blockedWriteStarted; attempt++) await new Promise(resolve => setTimeout(resolve, 10));
+ let exportSettled = false;
+ const pendingFileExport = wc.executeJavaScript('window.api.exportBackup()').then(result => { exportSettled = true; return result; });
+ await new Promise(resolve => setTimeout(resolve, 80));
+ const exportSettledBeforeWrite = exportSettled;
+ releaseBlockedWrite?.();
+ const [exportSaveResult, exportResult] = await Promise.all([delayedExportSave, pendingFileExport]);
+ const exportedRaceConfig = JSON.parse(fs.readFileSync(exportRacePath, 'utf-8'));
+ check('File backup waits for the ConfigStore write queue', exportSaveResult === true && exportResult?.ok === true && exportSettledBeforeWrite === false && exportedRaceConfig.globalSettings.webhookUrl === 'https://export-race.invalid/current');
+ blockedWriteMarker = '';
+ try { fs.unlinkSync(exportRacePath); } catch {}
+
+ const historyExportRacePath = path.join(app.getPath('userData'), 'ui-history-export-race.json');
+ dialog.showSaveDialog = async () => ({ canceled: false, filePath: historyExportRacePath });
+ activeConfigStore._historyMigrated = true;
+ fs.writeFileSync(activeConfigStore.historyPath, '[]', 'utf-8');
+ blockedHistoryWriteMarker = 'ui-history-export-race';
+ blockedHistoryWriteStarted = false;
+ releaseBlockedHistoryWrite = null;
+ const delayedHistoryExportWrite = activeConfigStore.appendHistory({ id: 'ui-history-export-race', files: [] });
+ for (let attempt = 0; attempt < 100 && !blockedHistoryWriteStarted; attempt++) await new Promise(resolve => setTimeout(resolve, 10));
+ let historyExportSettled = false;
+ const pendingHistoryExport = wc.executeJavaScript('window.api.exportBackup()').then(result => { historyExportSettled = true; return result; });
+ await new Promise(resolve => setTimeout(resolve, 80));
+ const historyExportSettledBeforeWrite = historyExportSettled;
+ releaseBlockedHistoryWrite?.();
+ const [historyExportWriteResult, historyExportResult] = await Promise.all([delayedHistoryExportWrite.then(() => true), pendingHistoryExport]);
+ check('File backup waits for the ConfigStore history queue', historyExportWriteResult === true && historyExportResult?.ok === true && historyExportSettledBeforeWrite === false);
+ blockedHistoryWriteMarker = '';
+ try { fs.unlinkSync(historyExportRacePath); } catch {}
+
+ const importRaceConfig = await wc.executeJavaScript('window.api.getConfig()');
+ for (const hoster of Object.keys(importRaceConfig.hosters || {})) importRaceConfig.hosters[hoster] = [];
+ importRaceConfig.hosters['byse.sx'] = [{ id: 'ui-imported-race-account', enabled: true, authType: 'api', apiKey: 'ui-imported-key' }];
+ importRaceConfig.globalSettings = { ...(importRaceConfig.globalSettings || {}), alwaysOnTop: false, webhookUrl: 'https://import-race.invalid/imported' };
+ const importRacePath = path.join(app.getPath('userData'), 'ui-import-race.json');
+ fs.writeFileSync(importRacePath, JSON.stringify(importRaceConfig), 'utf-8');
+ dialog.showOpenDialog = async () => ({ canceled: false, filePaths: [importRacePath] });
+ blockedHistoryWriteMarker = 'ui-history-import-race';
+ blockedHistoryWriteStarted = false;
+ releaseBlockedHistoryWrite = null;
+ const delayedHistoryImportWrite = activeConfigStore.appendHistory({ id: 'ui-history-import-race', files: [] });
+ for (let attempt = 0; attempt < 100 && !blockedHistoryWriteStarted; attempt++) await new Promise(resolve => setTimeout(resolve, 10));
+ blockedWriteMarker = 'ui-imported-race-account';
+ blockedWriteStarted = false;
+ releaseBlockedWrite = null;
+ const pendingImport = wc.executeJavaScript('window.api.importBackup()');
+ await new Promise(resolve => setTimeout(resolve, 80));
+ const importStartedBeforeHistoryWrite = blockedWriteStarted;
+ releaseBlockedHistoryWrite?.();
+ await delayedHistoryImportWrite;
+ for (let attempt = 0; attempt < 100 && !blockedWriteStarted; attempt++) await new Promise(resolve => setTimeout(resolve, 10));
+ const dryRunPruneResult = await wc.executeJavaScript('window.api.pruneHistory("all", { dryRun: true }).then(() => ({ ok: true }), error => ({ ok: false, error: error.message }))');
+ const staleSettings = { ...(importRaceConfig.globalSettings || {}), alwaysOnTop: true, webhookUrl: 'https://import-race.invalid/stale' };
+ const staleSave = wc.executeJavaScript('window.api.saveGlobalSettings(' + JSON.stringify(staleSettings) + ').then(() => ({ ok: true }), error => ({ ok: false, error: error.message }))');
+ const stalePrune = wc.executeJavaScript('window.api.pruneHistory("all").then(() => ({ ok: true }), error => ({ ok: false, error: error.message }))');
+ await new Promise(resolve => setTimeout(resolve, 80));
+ releaseBlockedWrite?.();
+ const [importResult, staleSaveResult, stalePruneResult] = await Promise.all([pendingImport, staleSave, stalePrune]);
+ const configAfterImportRace = await wc.executeJavaScript('window.api.getConfig()');
+ check('Import drains the ConfigStore history queue before replacement', importStartedBeforeHistoryWrite === false && importResult?.ok === true);
+ check('Import allows dry history previews but rejects mutating prune calls', dryRunPruneResult?.ok === true && stalePruneResult?.ok === false);
+ check('Import rejects stale config saves for the complete transition', staleSaveResult?.ok === false && configAfterImportRace.hosters['byse.sx']?.[0]?.id === 'ui-imported-race-account' && configAfterImportRace.globalSettings.alwaysOnTop === false && configAfterImportRace.globalSettings.webhookUrl === 'https://import-race.invalid/imported');
+
+ blockedWriteMarker = '';
+ blockedHistoryWriteMarker = '';
+ const importEpochWrites = await wc.executeJavaScript(\`(async () => {
+ beginConfigImport();
+ let releaseB;
+ const barrier = new Promise(resolve => { releaseB = resolve; });
+ const base = { ...(config.globalSettings || {}) };
+ const first = saveGlobalSettingsTracked({ ...base, webhookUrl: 'https://import-epoch.invalid/a' }).then(() => ({ ok: true }), error => ({ ok: false, code: error.code }));
+ const between = enqueueConfigWriteOperation(() => barrier).promise;
+ const second = saveGlobalSettingsTracked({ ...base, webhookUrl: 'https://import-epoch.invalid/b' }).then(() => ({ ok: true }), error => ({ ok: false, code: error.code }));
+ const firstResult = await first;
+ endConfigImport();
+ releaseB();
+ await between;
+ const secondResult = await second;
+ return { firstResult, secondResult, gateOpen: configImportInProgress === false };
+ })()\`);
+ check('Import epoch rejects queued writes even when the gate ends between them', importEpochWrites.firstResult?.code === 'CONFIG_WRITE_SUPERSEDED' && importEpochWrites.secondResult?.code === 'CONFIG_WRITE_SUPERSEDED' && importEpochWrites.gateOpen === true);
+
+ const importEpochConfig = structuredClone(configAfterImportRace);
+ for (const hoster of Object.keys(importEpochConfig.hosters || {})) importEpochConfig.hosters[hoster] = [];
+ importEpochConfig.hosters['byse.sx'] = [{ id: 'ui-import-epoch-account', enabled: true, authType: 'api', apiKey: 'ui-import-epoch-key' }];
+ importEpochConfig.globalSettings = { ...(importEpochConfig.globalSettings || {}), webhookUrl: 'https://import-epoch.invalid/imported' };
+ const importEpochPath = path.join(app.getPath('userData'), 'ui-import-epoch.json');
+ fs.writeFileSync(importEpochPath, JSON.stringify(importEpochConfig), 'utf-8');
+ dialog.showOpenDialog = async () => ({ canceled: false, filePaths: [importEpochPath] });
+ blockedWriteMarker = 'ui-import-epoch-account';
+ blockedWriteStarted = false;
+ releaseBlockedWrite = null;
+ const initialPendingQueueHandler = initialIpcHandlers.get('save-pending-queue');
+ let finalImportQueueStarted = false;
+ let releaseFinalImportQueue = null;
+ ipcMain.removeHandler('save-pending-queue');
+ ipcMain.handle('save-pending-queue', (event, pendingQueue) => {
+ if (!finalImportQueueStarted) {
+ finalImportQueueStarted = true;
+ return new Promise((resolve, reject) => {
+ releaseFinalImportQueue = () => Promise.resolve(initialPendingQueueHandler(event, pendingQueue)).then(resolve, reject);
+ });
+ }
+ return initialPendingQueueHandler(event, pendingQueue);
+ });
+ const pendingImportEpoch = wc.executeJavaScript('doBackupImport()');
+ for (let attempt = 0; attempt < 100 && !blockedWriteStarted; attempt++) await new Promise(resolve => setTimeout(resolve, 10));
+ releaseBlockedWrite?.();
+ for (let attempt = 0; attempt < 100 && !finalImportQueueStarted; attempt++) await new Promise(resolve => setTimeout(resolve, 10));
+ const importStateDuringFinalQueuePersist = await wc.executeJavaScript('({ gateClosed: configImportInProgress, webhookUrl: config.globalSettings.webhookUrl, accountId: config.hosters["byse.sx"]?.[0]?.id })');
+ const staleImportSettings = wc.executeJavaScript('saveGlobalSettingsTracked({ ...(config.globalSettings || {}), webhookUrl: "https://import-epoch.invalid/stale-after-commit" }).then(() => ({ ok: true }), error => ({ ok: false, code: error.code }))');
+ const staleImportAccounts = wc.executeJavaScript('saveConfigTracked({ hosters: { ...(config.hosters || {}), "byse.sx": [{ id: "ui-stale-account", enabled: true, authType: "api", apiKey: "stale" }] } }).then(() => ({ ok: true }), error => ({ ok: false, code: error.code }))');
+ releaseFinalImportQueue?.();
+ const [staleImportSettingsResult, staleImportAccountsResult] = await Promise.all([staleImportSettings, staleImportAccounts]);
+ await pendingImportEpoch;
+ const configAfterImportEpoch = await wc.executeJavaScript('window.api.getConfig()');
+ check('Import keeps its gate closed through apply and final queue persistence', importStateDuringFinalQueuePersist.gateClosed === true && importStateDuringFinalQueuePersist.webhookUrl === 'https://import-epoch.invalid/imported' && importStateDuringFinalQueuePersist.accountId === 'ui-import-epoch-account');
+ check('Import rejects stale settings and account writes until the full transition finishes', staleImportSettingsResult.code === 'CONFIG_WRITE_SUPERSEDED' && staleImportAccountsResult.code === 'CONFIG_WRITE_SUPERSEDED' && configAfterImportEpoch.hosters['byse.sx']?.[0]?.id === 'ui-import-epoch-account' && configAfterImportEpoch.globalSettings.webhookUrl === 'https://import-epoch.invalid/imported');
+
+ restoreInitialIpcHandler('save-pending-queue');
+ const importPersistFailureConfig = structuredClone(configAfterImportEpoch);
+ importPersistFailureConfig.globalSettings = { ...(importPersistFailureConfig.globalSettings || {}), webhookUrl: 'https://import-persist-failure.invalid/imported' };
+ const importPersistFailurePath = path.join(app.getPath('userData'), 'ui-import-persist-failure.json');
+ fs.writeFileSync(importPersistFailurePath, JSON.stringify(importPersistFailureConfig), 'utf-8');
+ dialog.showOpenDialog = async () => ({ canceled: false, filePaths: [importPersistFailurePath] });
+ let importQueueFailureAttempts = 0;
+ ipcMain.removeHandler('save-pending-queue');
+ ipcMain.handle('save-pending-queue', (event, pendingQueue) => {
+ importQueueFailureAttempts++;
+ if (importQueueFailureAttempts === 1) throw new Error('final queue persistence failed');
+ return initialPendingQueueHandler(event, pendingQueue);
+ });
+ await wc.executeJavaScript('doBackupImport()');
+ const importAfterQueueFailure = await wc.executeJavaScript('({ webhookUrl: config.globalSettings.webhookUrl, gateOpen: configImportInProgress === false, toast: document.getElementById("copyToast")?.textContent || "" })');
+ await wc.executeJavaScript('flushConfigWrites()');
+ check('Committed import remains applied when final queue persistence fails', importAfterQueueFailure.webhookUrl === 'https://import-persist-failure.invalid/imported' && importAfterQueueFailure.gateOpen === true && importAfterQueueFailure.toast.includes('Warteschlange') && importQueueFailureAttempts >= 2);
+ restoreInitialIpcHandler('save-pending-queue');
+
+ blockedWriteMarker = '';
+ blockedHistoryWriteMarker = '';
+ dialog.showSaveDialog = originalShowSaveDialog;
+ dialog.showOpenDialog = originalShowOpenDialog;
+ try { fs.unlinkSync(importRacePath); } catch {}
+ try { fs.unlinkSync(importEpochPath); } catch {}
+ try { fs.unlinkSync(importPersistFailurePath); } catch {}
+
+ const occupiedRemotePortServer = net.createServer();
+ await new Promise((resolve, reject) => {
+ occupiedRemotePortServer.once('error', reject);
+ occupiedRemotePortServer.listen(0, resolve);
+ });
+ const occupiedRemotePort = occupiedRemotePortServer.address().port;
+ const configBeforeRemoteFailure = JSON.parse(fs.readFileSync(activeConfigStore.filePath, 'utf-8'));
+ const alwaysOnTopAfterRemoteFailure = !Boolean(configBeforeRemoteFailure.globalSettings.alwaysOnTop);
+ const occupiedRemoteSettings = {
+ ...(configBeforeRemoteFailure.globalSettings.remote || {}),
+ enabled: true,
+ allowInput: true,
+ port: occupiedRemotePort,
+ token: 'ui-occupied-port-token'
+ };
+ const remoteSaveOutcome = await wc.executeJavaScript('saveRemoteSettingsTracked(' + JSON.stringify(occupiedRemoteSettings) + ').then(value => ({ resolved: true, value }), error => ({ resolved: false, error: error.message }))');
+ const configAfterRemoteFailure = JSON.parse(fs.readFileSync(activeConfigStore.filePath, 'utf-8'));
+ const followUpRemoteWrite = await wc.executeJavaScript('setAlwaysOnTopTracked(' + JSON.stringify(alwaysOnTopAfterRemoteFailure) + ').then(() => ({ ok: true }), error => ({ ok: false, error: error.message }))');
+ const configAfterRemoteFollowUp = JSON.parse(fs.readFileSync(activeConfigStore.filePath, 'utf-8'));
+ const reportedRemoteRuntimeFailure = remoteSaveOutcome.resolved === true
+ && remoteSaveOutcome.value?.saved === true
+ && typeof remoteSaveOutcome.value.runtimeError === 'string'
+ && remoteSaveOutcome.value.runtimeError.length > 0;
+ check('Remote runtime activation failure preserves settings without poisoning later writes', configAfterRemoteFailure.globalSettings.remote?.enabled === true && configAfterRemoteFailure.globalSettings.remote?.port === occupiedRemotePort && reportedRemoteRuntimeFailure === true && followUpRemoteWrite.ok === true && configAfterRemoteFollowUp.globalSettings.alwaysOnTop === alwaysOnTopAfterRemoteFailure);
+ await new Promise(resolve => occupiedRemotePortServer.close(resolve));
+ const restoredRemoteSettings = { ...occupiedRemoteSettings, enabled: false };
+ await wc.executeJavaScript('saveRemoteSettingsTracked(' + JSON.stringify(restoredRemoteSettings) + ').catch(() => {})');
+ await wc.executeJavaScript('setAlwaysOnTopTracked(' + JSON.stringify(Boolean(configBeforeRemoteFailure.globalSettings.alwaysOnTop)) + ').catch(() => {})');
+
+ const generatedRemoteSettings = await wc.executeJavaScript('saveRemoteSettingsTracked(' + JSON.stringify({ ...restoredRemoteSettings, enabled: true, token: '' }) + ')');
+ const generatedRemoteToken = generatedRemoteSettings?.settings?.token || '';
+ const canonicalRemoteAfterFullSave = await wc.executeJavaScript('(async () => { config.globalSettings = { ...(config.globalSettings || {}), remote: { ...' + JSON.stringify(restoredRemoteSettings) + ', enabled: false, token: "" } }; renderSettings(); const tokenInput = document.getElementById("remoteTokenInput"); if (tokenInput) tokenInput.value = ""; await saveSettings({ feedbackText: "Gespeichert" }); return config.globalSettings.remote?.token || ""; })()');
+ const configAfterGeneratedTokenSave = JSON.parse(fs.readFileSync(activeConfigStore.filePath, 'utf-8'));
+ check('Full settings save preserves the canonical remote token', generatedRemoteToken.length > 0 && canonicalRemoteAfterFullSave === generatedRemoteToken && configAfterGeneratedTokenSave.globalSettings.remote?.token === generatedRemoteToken);
+ await wc.executeJavaScript('saveRemoteSettingsTracked(' + JSON.stringify({ ...restoredRemoteSettings, enabled: false, token: generatedRemoteToken }) + ').catch(() => {})');
+
+ let directConfigWriteRelease = null;
+ let directConfigWriteStarted = false;
+ let rendererExportCalls = 0;
+ ipcMain.removeHandler('save-config');
+ ipcMain.handle('save-config', () => {
+ directConfigWriteStarted = true;
+ return new Promise(resolve => { directConfigWriteRelease = () => resolve(true); });
+ });
+ ipcMain.removeHandler('export-backup');
+ ipcMain.handle('export-backup', () => { rendererExportCalls++; return { ok: true, path: 'ui-renderer-export.mhu' }; });
+ await wc.executeJavaScript('(() => { HOSTERS.forEach(name => { config.hosters[name] = []; }); config.hosters["byse.sx"] = [{ id: "ui-tracked-account", enabled: true, authType: "api", apiKey: "tracked-key" }]; accountStatuses = { "ui-tracked-account": { status: "ok", message: "Bereit" } }; renderAccounts(); toggleAccount("ui-tracked-account"); })()');
+ for (let attempt = 0; attempt < 100 && !directConfigWriteStarted; attempt++) await new Promise(resolve => setTimeout(resolve, 10));
+ const pendingRendererExport = wc.executeJavaScript('doBackupExport()');
+ await new Promise(resolve => setTimeout(resolve, 80));
+ const rendererExportBeforeWrite = rendererExportCalls;
+ directConfigWriteRelease?.();
+ await pendingRendererExport;
+ check('Renderer export awaits direct account writes', directConfigWriteStarted === true && rendererExportBeforeWrite === 0 && rendererExportCalls === 1);
+
+ const failedSaveRepairOrder = [];
+ const failedSavePayloads = [];
+ let failedSaveAttempts = 0;
+ let fullSnapshotRepairCalls = 0;
+ ipcMain.removeHandler('save-global-settings');
+ ipcMain.handle('save-global-settings', (_event, payload) => {
+ failedSavePayloads.push(payload);
+ failedSaveAttempts++;
+ if (failedSaveAttempts === 1) {
+ failedSaveRepairOrder.push('failed-save');
+ throw new Error('tracked settings save failed');
+ }
+ failedSaveRepairOrder.push('retry-same-save');
+ return true;
+ });
+ ipcMain.removeHandler('save-config');
+ ipcMain.handle('save-config', () => {
+ fullSnapshotRepairCalls++;
+ failedSaveRepairOrder.push('full-snapshot');
+ return true;
+ });
+ ipcMain.removeHandler('export-backup');
+ ipcMain.handle('export-backup', () => {
+ failedSaveRepairOrder.push('export');
+ return { ok: true, path: 'ui-repaired-export.mhu' };
+ });
+ const failedSaveRepairAlert = await wc.executeJavaScript('(() => { const originalSettingsPayload = { ...(config.globalSettings || {}), alwaysOnTop: true, webhookUrl: "https://repair-export.invalid/original" }; config.globalSettings = originalSettingsPayload; window.__failedSaveRepairAlert = ""; window.alert = message => { window.__failedSaveRepairAlert = String(message); }; return saveGlobalSettingsTracked(originalSettingsPayload).catch(() => {}).then(() => { originalSettingsPayload.alwaysOnTop = false; originalSettingsPayload.webhookUrl = "https://repair-export.invalid/newer"; config.globalSettings = { ...originalSettingsPayload }; return doBackupExport(); }).then(() => window.__failedSaveRepairAlert); })()');
+ const failedSavePayloadRetriedExactly = failedSavePayloads.length === 2
+ && JSON.stringify(failedSavePayloads[0]) === JSON.stringify(failedSavePayloads[1])
+ && failedSavePayloads[1].alwaysOnTop === true
+ && failedSavePayloads[1].webhookUrl === 'https://repair-export.invalid/original';
+ check('Renderer retries the exact failed settings save before export without a full snapshot', failedSavePayloadRetriedExactly && fullSnapshotRepairCalls === 0 && failedSaveRepairOrder.join('|') === 'failed-save|retry-same-save|export' && failedSaveRepairAlert === '');
+
+ restoreInitialIpcHandler('save-global-settings');
+ restoreInitialIpcHandler('save-pending-queue');
+ const initialSaveGlobalSettingsHandler = initialIpcHandlers.get('save-global-settings');
+ const settingsRunnerMarker = 'https://runner-recovery.invalid/current';
+ let settingsRunnerAttempts = 0;
+ ipcMain.removeHandler('save-global-settings');
+ ipcMain.handle('save-global-settings', (event, payload) => {
+ if (payload?.webhookUrl === settingsRunnerMarker) {
+ settingsRunnerAttempts++;
+ if (settingsRunnerAttempts === 1) throw new Error('transient settings runner failure');
+ }
+ return initialSaveGlobalSettingsHandler(event, payload);
+ });
+ const settingsRunnerRecovery = await wc.executeJavaScript('(() => { const input = document.getElementById("webhookUrlInput"); input.value = "' + settingsRunnerMarker + '"; return saveSettings({ feedbackText: "Gespeichert" }).then(() => ({ firstFailed: false }), () => ({ firstFailed: true })).then(async result => { try { await flushPendingSettingsSaves(); result.flushOk = true; } catch (error) { result.flushOk = false; result.error = error.message; } return result; }); })()');
+ const configAfterSettingsRunnerRecovery = JSON.parse(fs.readFileSync(activeConfigStore.filePath, 'utf-8'));
+ check('Close flush recovers a rejected serialized settings runner', settingsRunnerRecovery.firstFailed === true && settingsRunnerRecovery.flushOk === true && settingsRunnerAttempts >= 2 && configAfterSettingsRunnerRecovery.globalSettings.webhookUrl === settingsRunnerMarker);
+ restoreInitialIpcHandler('save-global-settings');
+
+ const retainedWriteOrder = [];
+ let retainedOldAttempts = 0;
+ ipcMain.removeHandler('save-global-settings');
+ ipcMain.handle('save-global-settings', (_event, payload) => {
+ if (payload.webhookUrl === 'https://retry-queue.invalid/old') {
+ retainedOldAttempts++;
+ retainedWriteOrder.push('old-' + retainedOldAttempts);
+ if (retainedOldAttempts < 3) throw new Error('old write still failing');
+ } else if (payload.webhookUrl === 'https://retry-queue.invalid/new') {
+ retainedWriteOrder.push('new');
+ }
+ return true;
+ });
+ ipcMain.removeHandler('export-backup');
+ ipcMain.handle('export-backup', () => {
+ retainedWriteOrder.push('export');
+ return { ok: true, path: 'ui-retained-write-export.mhu' };
+ });
+ await wc.executeJavaScript('(() => { const oldSettings = { ...(config.globalSettings || {}), webhookUrl: "https://retry-queue.invalid/old" }; const newSettings = { ...oldSettings, webhookUrl: "https://retry-queue.invalid/new" }; return saveGlobalSettingsTracked(oldSettings).catch(() => {}).then(() => saveGlobalSettingsTracked(newSettings).catch(() => {})).then(() => doBackupExport()); })()');
+ check('Renderer retains newer writes when an older retry fails again', retainedWriteOrder.join('|') === 'old-1|old-2|old-3|new|export');
+
+ const importGateRetryOrder = [];
+ let importGateActive = true;
+ ipcMain.removeHandler('save-global-settings');
+ ipcMain.handle('save-global-settings', () => {
+ if (importGateActive) {
+ importGateRetryOrder.push('blocked-stale');
+ throw new Error('Einstellungen werden gerade importiert');
+ }
+ importGateRetryOrder.push('replayed-stale');
+ return true;
+ });
+ ipcMain.removeHandler('set-always-on-top');
+ ipcMain.handle('set-always-on-top', () => {
+ importGateRetryOrder.push('imported-state');
+ return true;
+ });
+ await wc.executeJavaScript('saveGlobalSettingsTracked({ ...(config.globalSettings || {}), webhookUrl: "https://import-gate.invalid/stale" }).catch(() => {})');
+ importGateActive = false;
+ await wc.executeJavaScript('setAlwaysOnTopTracked(false)');
+ check('Renderer never retries a settings write rejected by the import gate', importGateRetryOrder.join('|') === 'blocked-stale|imported-state');
+
+ const queueImportOrder = [];
+ const queueImportSnapshots = [];
+ let queueImportStarted = false;
+ let releaseQueueImport = null;
+ ipcMain.removeHandler('save-pending-queue');
+ ipcMain.handle('save-pending-queue', (_event, pendingQueue) => {
+ queueImportOrder.push('queue-save');
+ queueImportSnapshots.push(pendingQueue);
+ return true;
+ });
+ ipcMain.removeHandler('import-backup');
+ ipcMain.handle('import-backup', () => {
+ queueImportOrder.push('import');
+ queueImportStarted = true;
+ return new Promise(resolve => { releaseQueueImport = () => resolve({ ok: false, canceled: true }); });
+ });
+ const pendingQueueImport = wc.executeJavaScript('(() => { queueJobs = [{ id: "ui-queue-flush", file: "C:/ui/queue-flush.bin", fileName: "queue-flush.bin", hoster: "byse.sx", status: "preview", bytesTotal: 1 }]; rebuildJobIndex(); persistQueueStateSoon(false); return doBackupImport(); })()');
+ for (let attempt = 0; attempt < 100 && !queueImportStarted; attempt++) await new Promise(resolve => setTimeout(resolve, 10));
+ const queueWriteDuringImport = await wc.executeJavaScript('(() => { queueJobs = [{ id: "ui-import-dialog-terminal", file: "C:/ui/import-dialog-terminal.bin", fileName: "import-dialog-terminal.bin", hoster: "byse.sx", status: "done", bytesTotal: 10, bytesUploaded: 10, result: { download_url: "https://example.invalid/done" } }]; rebuildJobIndex(); return persistQueueStateNow().then(() => ({ ok: true }), error => ({ ok: false, error: error.message })); })()');
+ const terminalClearedBeforeImportFinished = queueImportSnapshots.some(snapshot => snapshot === null);
+ releaseQueueImport?.();
+ await pendingQueueImport;
+ await new Promise(resolve => setTimeout(resolve, 100));
+ const terminalClearedAfterCancel = queueImportSnapshots.some(snapshot => snapshot === null);
+ check('Import flushes the throttled queue save before invoking main', queueImportOrder[0] === 'queue-save' && queueImportOrder[1] === 'import');
+ check('Queue progress stays persistable while an import dialog is open', queueWriteDuringImport.ok === true && terminalClearedBeforeImportFinished === true && terminalClearedAfterCancel === true);
+
+ const importedQueueMerge = await wc.executeJavaScript('(() => { queueJobs = [{ id: "ui-live-queue-after-import", file: "C:/ui/live-after-import.bin", fileName: "live-after-import.bin", hoster: "byse.sx", status: "queued", bytesTotal: 12 }]; rebuildJobIndex(); const imported = structuredClone(config); imported.globalSettings = { ...(imported.globalSettings || {}), webhookUrl: "https://queue-merge.invalid/imported", pendingQueue: { savedAt: 1, queueJobs: [{ id: "ui-stale-import-queue" }] } }; applyImportedConfig(imported, "Importiert"); return { webhookUrl: config.globalSettings.webhookUrl, ids: config.globalSettings.pendingQueue?.queueJobs?.map(job => job.id) || [] }; })()');
+ check('Imported settings keep the live local queue in renderer memory', importedQueueMerge.webhookUrl === 'https://queue-merge.invalid/imported' && importedQueueMerge.ids.join('|') === 'ui-live-queue-after-import');
+ await wc.executeJavaScript('document.getElementById("copyToast")?.classList.remove("show")');
+
+ console.log('\\n=== History View ===');
+
+ ipcMain.removeHandler('get-history');
+ ipcMain.handle('get-history', () => [{
+ timestamp: '2026-08-10T10:00:00.000Z',
+ files: [
+ { name: 'ok.bin', results: [{ status: 'done', hoster: 'voe.sx', download_url: 'https://example.invalid/ok' }] },
+ { name: 'bad.bin', results: [{ status: 'error', hoster: 'byse.sx', error: 'Zugang abgelehnt' }] },
+ { name: 'stopped.bin', results: [{ status: 'aborted', hoster: 'doodstream.com' }] }
+ ]
+ }]);
+
+ await wc.executeJavaScript('_historyDirty = true; document.querySelector(".tab[data-view=\\'history\\']").click()');
+ await new Promise(r => setTimeout(r, 1000)); // Wait for async loadHistory
+
+ const historyActive = await wc.executeJavaScript('document.getElementById("history-view")?.classList.contains("active")');
+ check('History tab active', historyActive);
+
+ const historyWorkspaceLayout = await wc.executeJavaScript('(() => { const view = document.getElementById("history-view"); const sidebar = view?.querySelector(":scope > .view-sidebar"); const main = view?.querySelector(":scope > .view-main"); if (!sidebar || !main) return false; const sidebarRect = sidebar.getBoundingClientRect(); const mainRect = main.getBoundingClientRect(); return sidebarRect.width > 0 && mainRect.width > 0 && sidebarRect.right <= mainRect.left; })()');
+ check('History view separates sidebar and main workspace', historyWorkspaceLayout === true);
+
+ const historySidebarInformation = await wc.executeJavaScript('(() => { const sidebar = document.querySelector("#history-view > .view-sidebar")?.getBoundingClientRect(); const section = document.querySelector("#history-view .view-sidebar-section")?.getBoundingClientRect(); const retention = document.getElementById("historySidebarRetention")?.textContent?.trim(); return Boolean(sidebar && section && section.top >= sidebar.top + sidebar.height * 0.55 && retention === "Alles behalten"); })()');
+ check('History sidebar shows the active retention in its lower area', historySidebarInformation === true);
+
+ const historyFrameFit = await wc.executeJavaScript('(() => { const view = document.getElementById("history-view")?.getBoundingClientRect(); const status = document.getElementById("statusbar")?.getBoundingClientRect(); return Boolean(view && status && status.height > 0 && view.bottom <= status.top + 1 && status.bottom <= window.innerHeight + 1); })()');
+ check('History view and statusbar fit inside the viewport', historyFrameFit === true);
+
+ await captureVisual('04-history.png');
+
+ const emptyState = await wc.executeJavaScript('document.querySelector("#historyContainer .empty-state")?.textContent');
+ check('Empty state or history table shown', emptyState === 'Noch keine Uploads.' || emptyState === undefined);
+
+ const historyFilterState = await wc.executeJavaScript(\`(() => {
+ const inspect = (value) => {
+ document.querySelector('[data-history-filter="' + value + '"]').click();
+ return {
+ rows: [...document.querySelectorAll('#historyBody .history-row')].map(row => row.querySelector('.col-filename')?.textContent).sort(),
+ errors: document.querySelectorAll('#historyBody .history-row.error').length,
+ pressed: [...document.querySelectorAll('[data-history-filter]')].filter(button => button.getAttribute('aria-pressed') === 'true').map(button => button.dataset.historyFilter),
+ active: [...document.querySelectorAll('[data-history-filter].active')].map(button => button.dataset.historyFilter)
+ };
+ };
+ const initial = {
+ data: historyRowsData.length,
+ rows: [...document.querySelectorAll('#historyBody .history-row')].map(row => row.querySelector('.col-filename')?.textContent).sort(),
+ errors: document.querySelectorAll('#historyBody .history-row.error').length,
+ counts: ['historySidebarAllCount', 'historySidebarSuccessCount', 'historySidebarErrorCount'].map(id => document.getElementById(id)?.textContent)
+ };
+ const success = inspect('success');
+ const error = inspect('error');
+ const all = inspect('all');
+ return { initial, success, error, all, sourceLength: historyRowsData.length };
+ })()\`);
+ check('History keeps failed results in the renderer data model and All view', historyFilterState.initial.data === 3 && historyFilterState.initial.rows.join('|') === 'bad.bin|ok.bin|stopped.bin' && historyFilterState.initial.errors === 2 && historyFilterState.initial.counts.join('|') === '3|1|2');
+ check('History sidebar filters successful and failed rows without dropping source data', historyFilterState.success.rows.join('|') === 'ok.bin' && historyFilterState.success.errors === 0 && historyFilterState.error.rows.join('|') === 'bad.bin|stopped.bin' && historyFilterState.error.errors === 2 && historyFilterState.all.rows.length === 3 && historyFilterState.sourceLength === 3);
+ check('History sidebar exposes exactly one pressed filter', historyFilterState.success.pressed.join('|') === 'success' && historyFilterState.success.active.join('|') === 'success' && historyFilterState.error.pressed.join('|') === 'error' && historyFilterState.error.active.join('|') === 'error' && historyFilterState.all.pressed.join('|') === 'all' && historyFilterState.all.active.join('|') === 'all');
+
+ const historyErrorContrast = await wc.executeJavaScript(\`(() => {
+ document.querySelector('[data-history-filter="error"]').click();
+ const row = document.querySelector('#historyBody .history-row.error');
+ if (!row) return 0;
+ const parse = value => (value.match(/[0-9.]+/g) || []).slice(0, 3).map(Number);
+ const foreground = parse(getComputedStyle(row).color);
+ let node = row;
+ let background = [32, 32, 32];
+ while (node) {
+ const value = getComputedStyle(node).backgroundColor;
+ if (value && value !== 'rgba(0, 0, 0, 0)' && value !== 'transparent') {
+ background = parse(value);
+ break;
+ }
+ node = node.parentElement;
+ }
+ const opacity = Number(getComputedStyle(row).opacity);
+ const effective = foreground.map((channel, index) => channel * opacity + background[index] * (1 - opacity));
+ const luminance = rgb => {
+ const values = rgb.map(channel => {
+ const value = channel / 255;
+ return value <= 0.03928 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
+ });
+ return 0.2126 * values[0] + 0.7152 * values[1] + 0.0722 * values[2];
+ };
+ const foregroundLuminance = luminance(effective);
+ const backgroundLuminance = luminance(background);
+ return (Math.max(foregroundLuminance, backgroundLuminance) + 0.05) / (Math.min(foregroundLuminance, backgroundLuminance) + 0.05);
+ })()\`);
+ check('Failed history rows keep readable text contrast (' + historyErrorContrast.toFixed(2) + ':1)', historyErrorContrast >= 4.5);
+
+ console.log('\\n=== Global UI ===');
+
+ const shutdownHidden = await wc.executeJavaScript('document.getElementById("shutdownOverlay")?.style.display');
+ check('Shutdown overlay hidden', shutdownHidden === 'none');
+
+ const toastHidden = await wc.executeJavaScript('!document.getElementById("copyToast")?.classList.contains("show")');
+ check('Copy toast hidden', toastHidden);
+
+ const updateHidden = await wc.executeJavaScript('document.getElementById("updateBanner")?.style.display');
+ check('Update banner hidden', updateHidden === 'none');
+
+ const queueProgressVisibility = {};
+ for (const [label, width, height] of [['standard', 1100, 750], ['minimum', 800, 550]]) {
+ win.setSize(width, height);
+ await new Promise(resolve => setTimeout(resolve, 150));
+ queueProgressVisibility[label] = await wc.executeJavaScript(\`(() => {
+ document.querySelector('.tab[data-view="upload"]').click();
+ selectedFiles = [];
+ queueJobs = [{ id: 'ui-responsive', file: 'C:/ui/responsive.bin', fileName: 'responsive.bin', hoster: 'byse.sx', status: 'uploading', bytesUploaded: 512, bytesTotal: 1024, speedKbs: 64, elapsed: 5, remaining: 5, progress: 0.5 }];
+ rebuildJobIndex();
+ setUploadSidebarFilter('all');
+ updateUploadView();
+ renderQueueTable();
+ const container = document.getElementById('queueContainer');
+ container.scrollLeft = 0;
+ const header = document.querySelector('#queueTable thead .col-progress');
+ const cell = document.querySelector('#queueBody .queue-row .col-progress');
+ const row = document.querySelector('#queueBody .queue-row');
+ const containerRect = container.getBoundingClientRect();
+ const headerRect = header?.getBoundingClientRect();
+ const cellRect = cell?.getBoundingClientRect();
+ return {
+ headerVisible: Boolean(headerRect && headerRect.width > 0 && headerRect.left >= containerRect.left - 1 && headerRect.right <= containerRect.right + 1),
+ cellVisible: Boolean(cellRect && cellRect.width > 0 && cellRect.left >= containerRect.left - 1 && cellRect.right <= containerRect.right + 1),
+ headerHeight: headerRect?.height,
+ rowHeight: row?.getBoundingClientRect().height
+ };
+ })()\`);
+ }
+ const compactSettingsHeader = await wc.executeJavaScript('document.querySelector(".tab[data-view=settings]").click(); document.querySelector(".settings-header")?.getBoundingClientRect().height');
+ win.setBounds(originalBounds);
+ await new Promise(resolve => setTimeout(resolve, 150));
+ await wc.executeJavaScript('queueJobs = []; rebuildJobIndex(); updateUploadView(); renderQueueTable(); updateStatusBar();');
+ check('Upload progress stays visible at the standard window size', queueProgressVisibility.standard.headerVisible && queueProgressVisibility.standard.cellVisible);
+ check('Upload progress stays visible at the minimum window size', queueProgressVisibility.minimum.headerVisible && queueProgressVisibility.minimum.cellVisible);
+ check('Responsive queue keeps a compact table header', queueProgressVisibility.standard.headerHeight <= 34 && queueProgressVisibility.minimum.headerHeight <= 34);
+ check('Responsive queue keeps the fixed virtual row height', queueProgressVisibility.standard.rowHeight === 28 && queueProgressVisibility.minimum.rowHeight === 28);
+ check('Minimum window keeps the settings header compact', compactSettingsHeader <= 58);
+
+ const updateOverlayState = await wc.executeJavaScript('document.getElementById("headerUpdateBtn").focus(); showUpdateBanner({ remoteVersion: "9.9.9" }); (() => { const overlay = document.getElementById("updateBanner"); const dialog = overlay?.querySelector(".update-dialog"); return [overlay?.classList.contains("update-overlay"), overlay?.style.display, dialog?.getAttribute("role"), dialog?.getAttribute("aria-modal")].join("|"); })()');
+ check('Available update opens an accessible update dialog', updateOverlayState === 'true|flex|dialog|true');
+
+ await new Promise(resolve => setTimeout(resolve, 100));
+ const updateModalKeyboard = await wc.executeJavaScript(\`(() => {
+ const close = document.getElementById('updateCloseBtn');
+ const install = document.getElementById('installUpdateBtn');
+ const initialFocus = document.activeElement?.id;
+ const backgroundInert = document.querySelector('.app-header')?.inert === true && document.querySelector('.view.active')?.inert === true && document.getElementById('statusbar')?.inert === true;
+ install.focus();
+ install.dispatchEvent(new KeyboardEvent('keydown', { key: 'Tab', bubbles: true, cancelable: true }));
+ const forwardFocus = document.activeElement?.id;
+ close.focus();
+ close.dispatchEvent(new KeyboardEvent('keydown', { key: 'Tab', shiftKey: true, bubbles: true, cancelable: true }));
+ const backwardFocus = document.activeElement?.id;
+ return { initialFocus, backgroundInert, forwardFocus, backwardFocus };
+ })()\`);
+ check('Update dialog receives and traps keyboard focus', updateModalKeyboard.initialFocus === 'updateCloseBtn' && updateModalKeyboard.forwardFocus === 'updateCloseBtn' && updateModalKeyboard.backwardFocus === 'installUpdateBtn');
+ check('Update dialog makes the background inert', updateModalKeyboard.backgroundInert === true);
+
+ await captureVisual('05-update.png');
+
+ const updateDialogCopy = await wc.executeJavaScript('(() => { const title = document.getElementById("updateDialogTitle")?.textContent?.trim(); const message = document.getElementById("updateMessage")?.textContent?.trim(); return [title, message].join("|"); })()');
+ check('Update dialog names the available version', updateDialogCopy === 'Eine neue Version ist verfügbar|Update v9.9.9 verfügbar');
+
+ const updateDialogActions = await wc.executeJavaScript('[document.getElementById("dismissUpdateBtn")?.textContent?.trim(), document.getElementById("installUpdateBtn")?.textContent?.trim()].join("|")');
+ check('Update dialog offers later and install actions', updateDialogActions === 'Später erinnern|Jetzt updaten');
+
+ const updateHeaderHint = await wc.executeJavaScript('(() => { const button = document.getElementById("headerUpdateBtn"); return [button?.textContent?.trim(), button?.getAttribute("aria-label"), button?.dataset.tooltip].join("|"); })()');
+ check('Available update gives the header action a matching hint', updateHeaderHint === 'Update verfügbar|Update v9.9.9 verfügbar. Klicken zum Installieren.|Update v9.9.9 verfügbar. Klicken zum Installieren.');
+
+ const updateDialogDismissed = await wc.executeJavaScript('document.getElementById("dismissUpdateBtn")?.click(); (() => { const overlay = document.getElementById("updateBanner"); return [overlay?.style.display, overlay?.getAttribute("aria-hidden"), document.activeElement?.id, document.querySelector(".app-header")?.inert, document.querySelector(".view.active")?.inert, document.getElementById("statusbar")?.inert].join("|"); })()');
+ check('Update dialog closes and restores focus and background', updateDialogDismissed === 'none|true|headerUpdateBtn|false|false|false');
+
+ const busyUpdateState = await wc.executeJavaScript(\`(() => {
+ showUpdateBanner({ remoteVersion: '9.9.9' });
+ handleUpdateProgress({ stage: 'downloading', percent: 50 });
+ const overlay = document.getElementById('updateBanner');
+ document.getElementById('updateCloseBtn').click();
+ document.getElementById('dismissUpdateBtn').click();
+ overlay.dispatchEvent(new MouseEvent('click', { bubbles: true }));
+ document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true, cancelable: true }));
+ const progress = document.getElementById('updateProgressBar');
+ return {
+ display: overlay.style.display,
+ hidden: overlay.getAttribute('aria-hidden'),
+ closeDisabled: document.getElementById('updateCloseBtn').disabled,
+ dismissDisabled: document.getElementById('dismissUpdateBtn').disabled,
+ progressLabel: progress.getAttribute('aria-label'),
+ progressText: progress.getAttribute('aria-valuetext')
+ };
+ })()\`);
+ check('Busy update keeps its progress dialog open', busyUpdateState.display === 'flex' && busyUpdateState.hidden === 'false' && busyUpdateState.closeDisabled === true && busyUpdateState.dismissDisabled === true);
+ check('Update progress exposes an accessible live value', busyUpdateState.progressLabel === 'Update-Fortschritt' && busyUpdateState.progressText === 'Download 50%');
+
+ const updateErrorRecovery = await wc.executeJavaScript('handleUpdateProgress({ stage: "error", error: "Netzwerkfehler" }); document.getElementById("dismissUpdateBtn").click(); document.getElementById("updateBanner").style.display + "|" + document.getElementById("updateCloseBtn").disabled + "|" + document.getElementById("dismissUpdateBtn").disabled');
+ check('Update errors restore all close actions', updateErrorRecovery === 'none|false|false');
+
+ const initialInstallUpdateHandler = initialIpcHandlers.get('app:install-update');
+ const initialUpdateQueueHandler = initialIpcHandlers.get('save-pending-queue');
+ let installUpdateIpcCalls = 0;
+ ipcMain.removeHandler('app:install-update');
+ ipcMain.handle('app:install-update', () => {
+ installUpdateIpcCalls++;
+ return { started: true };
+ });
+ ipcMain.removeHandler('save-pending-queue');
+ ipcMain.handle('save-pending-queue', () => { throw new Error('update queue save failed'); });
+ const updateSaveFailure = await wc.executeJavaScript('showUpdateBanner({ remoteVersion: "9.9.9" }); installKnownUpdate().then(() => ({ busy: _updateInstallBusy, message: document.getElementById("updateMessage")?.textContent || "" }))');
+ check('Update preparation stops before install IPC when queue persistence fails', installUpdateIpcCalls === 0 && updateSaveFailure.busy === false && updateSaveFailure.message.includes('update queue save failed'));
+ await wc.executeJavaScript('handleUpdateProgress({ stage: "error", error: "Test cleanup" }); closeUpdateDialog()');
+ ipcMain.removeHandler('app:install-update');
+ if (initialInstallUpdateHandler) registerIpcHandler('app:install-update', initialInstallUpdateHandler);
+ ipcMain.removeHandler('save-pending-queue');
+ if (initialUpdateQueueHandler) registerIpcHandler('save-pending-queue', initialUpdateQueueHandler);
+ await wc.executeJavaScript('flushConfigWrites()');
+
+ const stackedDialogState = await wc.executeJavaScript(\`(() => {
+ openAccountModal(null);
+ showUpdateBanner({ remoteVersion: '9.9.9' });
+ document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true, cancelable: true }));
+ const state = document.getElementById('updateBanner').style.display + '|' + document.getElementById('accountModal').style.display;
+ if (document.getElementById('updateBanner').style.display !== 'none') closeUpdateDialog();
+ if (document.getElementById('accountModal').style.display !== 'none') closeAccountModal();
+ return state;
+ })()\`);
+ check('Escape closes only the topmost update dialog', stackedDialogState === 'none|flex');
+
+ if (visualScreenshotDir) {
+ win.setSize(800, 550);
+ await wc.executeJavaScript('document.querySelector(".tab[data-view=\\\'settings\\\']").click(); document.querySelector("[data-settings-page=\\\'allgemein\\\']")?.click(); (() => { const search = document.getElementById("settingsSearchInput"); if (search) { search.value = ""; search.dispatchEvent(new Event("input", { bubbles: true })); } document.querySelector(".settings-content")?.scrollTo(0, 0); })()');
+ await captureVisual('06-settings-800x550.png');
+ win.setBounds(originalBounds);
+ }
+
+ restoreInitialIpcHandler('save-global-settings');
+ restoreInitialIpcHandler('save-pending-queue');
+ const keepaliveWindow = new BrowserWindow({ show: false });
+ realAppQuit = app.quit.bind(app);
+ app.relaunch = () => { relaunchCalls++; };
+ app.quit = () => {
+ if (!win.isDestroyed()) win.close();
+ };
+ await wc.executeJavaScript('window.api.removeAllListeners()');
+ await wc.executeJavaScript('window.api.restartApp()');
+ await new Promise(resolve => setTimeout(resolve, 1700));
+ const lostCloseRequestRecovered = !win.isDestroyed();
+ await wc.executeJavaScript('window.api.onPrepareClose(prepareForWindowClose)');
+ await wc.executeJavaScript('window.api.onUpdateProgress(handleUpdateProgress)');
+ check('Lost restart close request leaves the window open for a later normal quit', lostCloseRequestRecovered === true);
+
+ const originalSavePendingQueue = activeConfigStore.savePendingQueue.bind(activeConfigStore);
+ let rejectHungFinalQueueWrite = null;
+ let hangFinalQueueWrite = true;
+ activeConfigStore.savePendingQueue = (pendingQueue, options) => {
+ if (hangFinalQueueWrite && options?.allowDuringQuiesce === true) {
+ hangFinalQueueWrite = false;
+ return new Promise((_resolve, reject) => { rejectHungFinalQueueWrite = reject; });
+ }
+ return originalSavePendingQueue(pendingQueue, options);
+ };
+ const initialFinishCloseHandler = initialIpcHandlers.get('app:finish-close');
+ let closeReadyAttempt = null;
+ let closeRestoreAttempt = null;
+ let restoreAckRequested = false;
+ let releaseRestoreAck = null;
+ ipcMain.removeHandler('app:finish-close');
+ ipcMain.handle('app:finish-close', async (event, payload) => {
+ const ready = payload && typeof payload === 'object' ? payload.ready !== false : payload !== false;
+ if (ready) {
+ closeReadyAttempt = payload && typeof payload === 'object' ? payload.attempt : null;
+ } else {
+ closeRestoreAttempt = payload && typeof payload === 'object' ? payload.attempt : null;
+ restoreAckRequested = true;
+ await new Promise(resolve => { releaseRestoreAck = resolve; });
+ }
+ return initialFinishCloseHandler(event, payload);
+ });
+ await wc.executeJavaScript('(() => { queuePersistThrottle.cancel(); selectedFiles = []; queueJobs = [{ id: "ui-close-timeout-job", file: "C:/ui/close-timeout.bin", fileName: "close-timeout.bin", hoster: "byse.sx", status: "queued", bytesUploaded: 0, bytesTotal: 1, speedKbs: 0, elapsed: 0, remaining: 0, progress: 0 }]; rebuildJobIndex(); return true; })()');
+ await wc.executeJavaScript('showUpdateBanner({ remoteVersion: "9.9.9" }); installKnownUpdate()');
+ await waitUntil(() => restoreAckRequested, 4000);
+ const recoveryBeforeAck = await wc.executeJavaScript('({ state: closePreparationState, promiseCleared: closePreparationPromise === null, overlayVisible: document.getElementById("shutdownOverlay")?.style.display === "flex", inertRetained: closePreparationInertState.length > 0 && closePreparationInertState.every(({ element }) => element.inert === true) })');
+ const windowStayedOpenAfterCloseFailure = !win.isDestroyed();
+ rejectHungFinalQueueWrite?.(new Error('final queue write timeout'));
+ releaseRestoreAck?.();
+ const boundedCloseRecovery = await waitUntil(async () => {
+ if (win.isDestroyed()) return null;
+ const state = await wc.executeJavaScript('({ state: closePreparationState, promiseCleared: closePreparationPromise === null, overlayHidden: document.getElementById("shutdownOverlay")?.style.display === "none", inertRestored: closePreparationInertState.length === 0, failedWrites: failedConfigWriteOperations.length })');
+ return state.state === 'open' && state.promiseCleared ? state : null;
+ }, 4000);
+ activeConfigStore.savePendingQueue = originalSavePendingQueue;
+ const closeRecoveryMarker = 'https://close-recovery.invalid/after-timeout';
+ const writeAfterCloseRecovery = await wc.executeJavaScript('saveGlobalSettingsTracked({ ...(config.globalSettings || {}), webhookUrl: "' + closeRecoveryMarker + '" }).then(() => ({ ok: true }), error => ({ ok: false, error: error.message }))');
+ const historyAfterCloseRecovery = await activeConfigStore.appendHistory({ id: 'ui-close-recovery-history', files: [] }).then(() => ({ ok: true }), error => ({ ok: false, error: error.message }));
+ const configAfterCloseRecovery = JSON.parse(fs.readFileSync(activeConfigStore.filePath, 'utf-8'));
+ const recoveredQueue = configAfterCloseRecovery.globalSettings.pendingQueue?.queueJobs || [];
+ const failedUpdateUi = await wc.executeJavaScript('({ busy: _updateInstallBusy, message: document.getElementById("updateMessage")?.textContent || "" })');
+ const closeRecoveryEvidence = { windowStayedOpenAfterCloseFailure, recoveryBeforeAck, boundedCloseRecovery, closeReadyAttempt, closeRestoreAttempt, writesQuiesced: activeConfigStore._writesQuiesced, writeAfterCloseRecovery, historyAfterCloseRecovery, persistedWebhookUrl: configAfterCloseRecovery.globalSettings.webhookUrl, recoveredQueue: recoveredQueue.map(job => job.id), preparedUpdateMockCalls, launchedUpdateMockCalls, failedUpdateUi };
+ const closeRecoveryOk = windowStayedOpenAfterCloseFailure === true && recoveryBeforeAck.state === 'recovering' && recoveryBeforeAck.promiseCleared === false && recoveryBeforeAck.overlayVisible === true && recoveryBeforeAck.inertRetained === true && boundedCloseRecovery?.state === 'open' && boundedCloseRecovery.promiseCleared === true && boundedCloseRecovery.overlayHidden === true && boundedCloseRecovery.inertRestored === true && boundedCloseRecovery.failedWrites === 0 && activeConfigStore._writesQuiesced === false && Number.isInteger(closeReadyAttempt) && closeRestoreAttempt === closeReadyAttempt && writeAfterCloseRecovery.ok === true && historyAfterCloseRecovery.ok === true && configAfterCloseRecovery.globalSettings.webhookUrl === closeRecoveryMarker && recoveredQueue.some(job => job.id === 'ui-close-timeout-job') && preparedUpdateMockCalls === 1 && launchedUpdateMockCalls === 0 && failedUpdateUi.busy === false && failedUpdateUi.message.includes('nicht gestartet');
+ if (!closeRecoveryOk) console.log('Close recovery evidence: ' + JSON.stringify(closeRecoveryEvidence));
+ check('Close recovery waits for its correlated restore ACK and drains retained writes before reopening', closeRecoveryOk);
+ restoreInitialIpcHandler('app:finish-close');
+
+ const closeSnapshotWebhook = 'https://close-persist.invalid/current';
+ const closeSnapshotJobId = 'ui-close-persist-job';
+ activeConfigStore._historyMigrated = true;
+ blockedHistoryWriteMarker = 'ui-close-history-write';
+ blockedHistoryWriteStarted = false;
+ releaseBlockedHistoryWrite = null;
+ const pendingCloseHistoryWrite = activeConfigStore.appendHistory({ id: 'ui-close-history-write', files: [] });
+ await waitUntil(() => blockedHistoryWriteStarted);
+ await wc.executeJavaScript('(() => { config.globalSettings = { ...(config.globalSettings || {}), webhookUrl: "' + closeSnapshotWebhook + '" }; const webhookInput = document.getElementById("webhookUrlInput"); if (webhookInput) webhookInput.value = "' + closeSnapshotWebhook + '"; selectedFiles = []; queueJobs = [{ id: "' + closeSnapshotJobId + '", file: "C:/ui/close-persist.bin", fileName: "close-persist.bin", hoster: "byse.sx", status: "queued", bytesUploaded: 0, bytesTotal: 4096, speedKbs: 0, elapsed: 0, remaining: 0, progress: 0 }]; rebuildJobIndex(); scheduleSettingsSave(); persistQueueStateSoon(false); return true; })()');
+ let mainWindowClosed = false;
+ win.once('closed', () => { mainWindowClosed = true; });
+ await wc.executeJavaScript('showUpdateBanner({ remoteVersion: "9.9.9" }); installKnownUpdate()');
+ const rendererCloseSealed = await waitUntil(async () => !win.isDestroyed() && await wc.executeJavaScript('closePreparationState === "sealed"'));
+ const windowStayedOpenForClosePersistence = blockedHistoryWriteStarted === true && !win.isDestroyed();
+ const closeUiQuiesced = await wc.executeJavaScript('document.getElementById("shutdownOverlay")?.style.display === "flex" && closePreparationInertState.length > 0 && closePreparationInertState.every(({ element }) => element.inert === true)');
+ const postSealMainWrite = await wc.executeJavaScript('window.api.saveGlobalSettings({ ...(config.globalSettings || {}), webhookUrl: "https://close-persist.invalid/post-seal" }).then(() => ({ ok: true }), error => ({ ok: false, error: error.message }))');
+ await wc.executeJavaScript('(() => { queueJobs.push({ id: "ui-post-seal-job", file: "C:/ui/post-seal.bin", fileName: "post-seal.bin", hoster: "byse.sx", status: "queued", bytesUploaded: 0, bytesTotal: 1 }); rebuildJobIndex(); persistQueueStateSoon(false); scheduleSettingsSave(); return true; })()');
+ await new Promise(resolve => setTimeout(resolve, 650));
+ releaseBlockedHistoryWrite?.();
+ await pendingCloseHistoryWrite;
+ await waitUntil(() => mainWindowClosed);
+ const closePersistedConfig = JSON.parse(fs.readFileSync(activeConfigStore.filePath, 'utf-8'));
+ const closePersistedQueue = closePersistedConfig.globalSettings.pendingQueue?.queueJobs || [];
+ check('Window close waits for asynchronous persistence of the latest renderer snapshot', keepaliveWindow.isDestroyed() === false && blockedHistoryWriteStarted === true && windowStayedOpenForClosePersistence === true && mainWindowClosed === true && closePersistedConfig.globalSettings.webhookUrl === closeSnapshotWebhook && closePersistedQueue.some(job => job.id === closeSnapshotJobId));
+ check('Window close seals renderer writes before the final snapshot is committed', rendererCloseSealed === true && closeUiQuiesced === true && !closePersistedQueue.some(job => job.id === 'ui-post-seal-job'));
+ check('Main rejects config producers after the close snapshot is sealed', postSealMainWrite.ok === false);
+
+ } catch (err) {
+ console.log('Test error:', err && err.stack ? err.stack : err.message);
+ failed++;
+ }
+
+ const printResults = () => {
+ console.log('\\n=== Results ===');
+ results.forEach(r => console.log(r));
+ console.log('\\nTotal: ' + (passed + failed) + ' | Passed: ' + passed + ' | Failed: ' + failed);
+ };
+ if (realAppQuit) {
+ app.once('will-quit', () => {
+ check('Lost restart intent does not relaunch during the later normal quit', relaunchCalls === 0);
+ check('Approved update launches its prepared installer exactly once', preparedUpdateMockCalls === 2 && launchedUpdateMockCalls === 1);
+ printResults();
+ process.exitCode = failed > 0 ? 1 : 0;
+ });
+ realAppQuit();
+ return;
+ }
+ printResults();
+ app.exit(failed > 0 ? 1 : 0);
+}, 5000);
+`;
+
+try {
+ fs.writeFileSync(injectPath, testScript, 'utf-8');
+ execFileSync(process.execPath, ['--check', injectPath], { cwd: path.join(__dirname, '..'), stdio: 'pipe' });
+ const electronPath = path.join(__dirname, '..', 'node_modules', 'electron', 'dist', 'electron.exe');
+ const mainPath = path.join(__dirname, '..', 'main.js');
+
+ const result = execFileSync(
+ electronPath,
+ [`--user-data-dir=${userDataPath}`, '--require', injectPath, mainPath],
+ { cwd: path.join(__dirname, '..'), timeout: 45000, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }
+ );
+ console.log(result);
+ const isolatedConfigPath = path.join(userDataPath, 'electron-config.json');
+ if (!fs.existsSync(isolatedConfigPath)) throw new Error(`Isolated UI config was not created: ${isolatedConfigPath}`);
+} catch (err) {
+ // timeout or exit code - still print output
+ if (err.stdout) console.log(err.stdout);
+ if (err.stderr) {
+ const filtered = err.stderr.split('\n')
+ .filter(l => !l.includes('cache_util') && !l.includes('disk_cache') && !l.includes('gpu_disk_cache'))
+ .join('\n');
+ if (filtered.trim()) console.error(filtered);
+ }
+ process.exitCode = Number.isInteger(err.status) && err.status !== 0 ? err.status : 1;
+} finally {
+ try { fs.unlinkSync(injectPath); } catch {}
+ try { fs.rmSync(userDataPath, { recursive: true, force: true }); } catch {}
+}
diff --git a/tests/updater-version.test.js b/tests/updater-version.test.js
new file mode 100644
index 0000000..04ade35
--- /dev/null
+++ b/tests/updater-version.test.js
@@ -0,0 +1,143 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const path = require('node:path');
+const fs = require('node:fs');
+const os = require('node:os');
+const { pathToFileURL } = require('node:url');
+
+const { isNewer, resolveReleaseVersion, prepareUpdate, launchPreparedUpdate } = require('../lib/updater');
+const releasePlanUrl = pathToFileURL(path.resolve(__dirname, '../scripts/release-plan.mjs')).href;
+
+test('bridge title resolves product version instead of transport tag', () => {
+ assert.equal(resolveReleaseVersion({ name: 'Multi-Hoster-Upload v2.0.1', tag_name: 'v3.3.109' }), '2.0.1');
+ assert.equal(isNewer('2.0.1', '2.0.1'), false);
+ assert.equal(isNewer('2.0.2', '2.0.1'), true);
+});
+
+test('release arguments reject a malformed transport tag', async () => {
+ const { parseReleaseArgs } = await import(releasePlanUrl);
+ assert.throws(
+ () => parseReleaseArgs(['2.0.1', '--transport-tag', '3.3.109', 'Bridge', '--dry-run']),
+ /--transport-tag must match vX\.Y\.Z/
+ );
+});
+
+test('update preparation writes a verified installer without launching it', async () => {
+ const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mhu-updater-test-'));
+ const installer = Buffer.alloc(128 * 1024, 0);
+ installer[0] = 0x4d;
+ installer[1] = 0x5a;
+ let reads = 0;
+ const progress = [];
+ try {
+ const prepared = await prepareUpdate(value => progress.push(value), {
+ checkResult: {
+ available: true,
+ assetUrl: 'https://update.invalid/setup.exe',
+ assetName: 'setup.exe',
+ assetSize: installer.length,
+ latestYmlUrl: null
+ },
+ tempDir,
+ fetchImpl: async () => ({
+ ok: true,
+ status: 200,
+ body: {
+ getReader: () => ({
+ read: async () => {
+ reads++;
+ return reads === 1 ? { done: false, value: installer } : { done: true };
+ }
+ })
+ }
+ })
+ });
+
+ assert.equal(prepared.installerPath, path.join(tempDir, 'setup.exe'));
+ assert.deepEqual(fs.readFileSync(prepared.installerPath), installer);
+ assert.equal(progress.at(-1).stage, 'prepared');
+ } finally {
+ fs.rmSync(tempDir, { recursive: true, force: true });
+ }
+});
+
+test('a prepared installer launches at most once', () => {
+ const calls = [];
+ const child = { unrefCalls: 0, unref() { this.unrefCalls++; } };
+ const prepared = { installerPath: 'C:\\Temp\\mhu-setup.exe' };
+ const spawnImpl = (...args) => {
+ calls.push(args);
+ return child;
+ };
+
+ assert.equal(launchPreparedUpdate(prepared, { spawnImpl }), true);
+ assert.equal(launchPreparedUpdate(prepared, { spawnImpl }), false);
+ assert.equal(calls.length, 1);
+ assert.deepEqual(calls[0], [
+ prepared.installerPath,
+ ['/S', '--updated', '--force-run'],
+ { detached: true, stdio: 'ignore' }
+ ]);
+ assert.equal(child.unrefCalls, 1);
+});
+
+test('release plan keeps product artifacts separate from the transport tag', async () => {
+ const { createReleasePlan, parseReleaseArgs, renderLatestYml } = await import(releasePlanUrl);
+ const plan = createReleasePlan(parseReleaseArgs(['2.0.6', '--transport-tag', 'v3.3.114', 'Interface', 'redesign']));
+ const latestYml = renderLatestYml(plan, 'abc123', 456, '2026-08-07T12:00:00.000Z');
+ assert.deepEqual({
+ version: plan.version,
+ transportTag: plan.transportTag,
+ releaseTitle: plan.releaseTitle,
+ releaseBody: plan.releaseBody,
+ expectedArtifacts: plan.expectedArtifacts,
+ latestYml
+ }, {
+ version: '2.0.6',
+ transportTag: 'v3.3.114',
+ releaseTitle: 'Multi-Hoster-Upload v2.0.6',
+ releaseBody: 'Interface redesign',
+ expectedArtifacts: [
+ 'Multi-Hoster-Upload Setup 2.0.6.exe',
+ 'Multi-Hoster-Upload 2.0.6.exe',
+ 'Multi-Hoster-Upload Setup 2.0.6.exe.blockmap',
+ 'latest.yml'
+ ],
+ latestYml: "version: 2.0.6\nfiles:\n - url: Multi-Hoster-Upload Setup 2.0.6.exe\n sha512: abc123\n size: 456\npath: Multi-Hoster-Upload Setup 2.0.6.exe\nsha512: abc123\nreleaseDate: '2026-08-07T12:00:00.000Z'\n"
+ });
+});
+
+test('compatible existing release preserves the recovery id', async () => {
+ const { createReleasePlan, parseReleaseArgs, resolveExistingReleaseId } = await import(releasePlanUrl);
+ const plan = createReleasePlan(parseReleaseArgs(['2.0.1', '--transport-tag', 'v3.3.109', 'Bridge notes']));
+ const release = {
+ id: 81,
+ tag_name: 'v3.3.109',
+ name: 'Multi-Hoster-Upload v2.0.1',
+ body: 'Bridge notes',
+ draft: false,
+ prerelease: false,
+ assets: []
+ };
+
+ assert.equal(resolveExistingReleaseId(plan, release), 81);
+});
+
+test('incompatible existing release title fails closed', async () => {
+ const { createReleasePlan, parseReleaseArgs, resolveExistingReleaseId } = await import(releasePlanUrl);
+ const plan = createReleasePlan(parseReleaseArgs(['2.0.1', '--transport-tag', 'v3.3.109', 'Bridge notes']));
+ const release = {
+ id: 81,
+ tag_name: 'v3.3.109',
+ name: 'Multi-Hoster-Upload v3.3.109',
+ body: 'Old transport release',
+ draft: false,
+ prerelease: false,
+ assets: []
+ };
+
+ assert.throws(
+ () => resolveExistingReleaseId(plan, release),
+ /Refusing recovery for v3\.3\.109: existing release title "Multi-Hoster-Upload v3\.3\.109" does not match "Multi-Hoster-Upload v2\.0\.1"/
+ );
+});
diff --git a/tests/upload-log.test.js b/tests/upload-log.test.js
new file mode 100644
index 0000000..45da127
--- /dev/null
+++ b/tests/upload-log.test.js
@@ -0,0 +1,80 @@
+const { test } = require('node:test');
+const assert = require('node:assert');
+const { formatUploadLogLine, parseUploadLogLine } = require('../lib/upload-log');
+const { partitionRestoredJobsByLog } = require('../lib/queue-dedup');
+
+function previewJob(fileName, hoster) {
+ return { status: 'preview', fileName, hoster, file: `C:/dl/${fileName}` };
+}
+
+test('writer -> reader round trip: parsed ts is the same epoch frame as the source Date getTime', () => {
+ const d = new Date(2026, 5, 19, 12, 0, 30);
+ const line = formatUploadLogLine(d, 'voe.sx', 'https://voe.sx/x', 'a.mkv');
+ const parsed = parseUploadLogLine(line);
+ assert.equal(parsed.hoster, 'voe.sx');
+ assert.equal(parsed.fileName, 'a.mkv');
+ assert.equal(parsed.ts, d.getTime(), 'parser ts must equal the writer Date epoch (no tz shift)');
+});
+
+test('SEAM: a real appendUploadLog-format line drops a preview ghost vs a savedAt taken BEFORE completion', () => {
+ const completion = new Date(2026, 5, 19, 12, 0, 30);
+ const line = formatUploadLogLine(completion, 'voe.sx', 'link', 'a.mkv');
+ const parsed = parseUploadLogLine(line);
+ const savedAt = completion.getTime() - 5000;
+ const { removed, kept } = partitionRestoredJobsByLog([previewJob('a.mkv', 'voe.sx')], [parsed], savedAt);
+ assert.equal(removed.length, 1, 'a file logged after the snapshot is a ghost and must drop');
+ assert.equal(kept.length, 0);
+});
+
+test('SEAM: the same real line is KEPT vs a savedAt taken AFTER completion (intentional re-upload)', () => {
+ const completion = new Date(2026, 5, 19, 12, 0, 30);
+ const parsed = parseUploadLogLine(formatUploadLogLine(completion, 'voe.sx', 'link', 'a.mkv'));
+ const savedAt = completion.getTime() + 5000;
+ const { removed, kept } = partitionRestoredJobsByLog([previewJob('a.mkv', 'voe.sx')], [parsed], savedAt);
+ assert.equal(removed.length, 0, 'an older upload than the snapshot is a deliberate re-queue and must survive');
+ assert.equal(kept.length, 1);
+});
+
+test('parseUploadLogLine skips comments, blanks and malformed lines', () => {
+ assert.equal(parseUploadLogLine('# fileuploader log'), null);
+ assert.equal(parseUploadLogLine(''), null);
+ assert.equal(parseUploadLogLine(' '), null);
+ assert.equal(parseUploadLogLine('only|three|parts|here'), null);
+ assert.equal(parseUploadLogLine(null), null);
+ assert.equal(parseUploadLogLine(42), null);
+});
+
+test('parseUploadLogLine: missing/garbage timestamp yields ts=undefined (legacy lines still match by name)', () => {
+ const parsed = parseUploadLogLine('|voe.sx|link||a.mkv|');
+ assert.equal(parsed.hoster, 'voe.sx');
+ assert.equal(parsed.fileName, 'a.mkv');
+ assert.equal(parsed.ts, undefined);
+});
+
+test('parseUploadLogLine: a pipe in the link does NOT shift the filename field (entry not lost)', () => {
+ const line = formatUploadLogLine(new Date(2026, 5, 19, 12, 0, 0), 'byse.sx', 'https://h.io/a|b', 'movie.mkv');
+ const parsed = parseUploadLogLine(line);
+ assert.equal(parsed.hoster, 'byse.sx');
+ assert.equal(parsed.fileName, 'movie.mkv', 'filename is taken as the last non-empty field, robust to link pipes');
+});
+
+test('parseUploadLogLine: two pipes in the link still parse the correct filename', () => {
+ const line = formatUploadLogLine(new Date(2026, 5, 19, 12, 0, 0), 'byse.sx', 'https://h.io/a|b|c', 'movie.mkv');
+ const parsed = parseUploadLogLine(line);
+ assert.equal(parsed.fileName, 'movie.mkv');
+});
+
+test('parseUploadLogLine: a leading-space filename is preserved (matches the untrimmed queue-job key)', () => {
+ const line = formatUploadLogLine(new Date(2026, 5, 19, 12, 0, 0), 'voe.sx', 'https://h.io/a', ' movie.mkv');
+ const parsed = parseUploadLogLine(line);
+ assert.equal(parsed.fileName, ' movie.mkv', 'filename is NOT trimmed, so it matches the OS basename verbatim');
+});
+
+test('SEAM: a leading-space filename round-trips and the gate still drops its ghost', () => {
+ const completion = new Date(2026, 5, 19, 12, 0, 30);
+ const parsed = parseUploadLogLine(formatUploadLogLine(completion, 'voe.sx', 'l', ' spaced.mp4'));
+ const savedAt = completion.getTime() - 5000;
+ const job = { status: 'preview', fileName: ' spaced.mp4', hoster: 'voe.sx', file: 'C:/dl/ spaced.mp4' };
+ const { removed } = partitionRestoredJobsByLog([job], [parsed], savedAt);
+ assert.equal(removed.length, 1, 'leading-space filename now matches end-to-end (was a mismatch before)');
+});
diff --git a/tests/upload-manager.test.js b/tests/upload-manager.test.js
new file mode 100644
index 0000000..bec2510
--- /dev/null
+++ b/tests/upload-manager.test.js
@@ -0,0 +1,1045 @@
+const { describe, it, mock, beforeEach } = require('node:test');
+const assert = require('node:assert/strict');
+const path = require('path');
+const { EventEmitter } = require('events');
+
+// We need to mock fs.statSync and the hoster upload functions before requiring upload-manager
+// Use node:test mock.module (available in Node 22+)
+
+describe('UploadManager', () => {
+ let UploadManager;
+ let mockUploadFile;
+ let fakeFileSize;
+
+ beforeEach(() => {
+ fakeFileSize = 1024 * 1024; // 1 MB default
+
+ // Clear module cache for fresh mocks each test
+ delete require.cache[require.resolve('../lib/upload-manager')];
+
+ // Mock the hosters module
+ mockUploadFile = mock.fn(async (hoster, filePath, apiKey, onProgress, signal, throttle) => {
+ // Simulate upload progress
+ if (onProgress) {
+ onProgress(fakeFileSize / 2, fakeFileSize);
+ onProgress(fakeFileSize, fakeFileSize);
+ }
+ return { download_url: `https://${hoster}/test123`, embed_url: null, file_code: 'test123' };
+ });
+
+ // Override require for hosters
+ const origRequire = module.constructor.prototype.require;
+ const hosters = require('../lib/hosters');
+ hosters.uploadFile = mockUploadFile;
+ hosters.prefetchBaseline = async () => null;
+
+ // Mock fs.statSync + fs.promises.stat for test file paths
+ const fs = require('fs');
+ const origStatSync = fs.statSync;
+ fs.statSync = function(p) {
+ if (typeof p === 'string' && p.startsWith('/test/')) {
+ return { size: fakeFileSize };
+ }
+ return origStatSync.call(this, p);
+ };
+ const origStat = fs.promises.stat;
+ fs.promises.stat = async function(p) {
+ if (typeof p === 'string' && p.startsWith('/test/')) {
+ return { size: fakeFileSize };
+ }
+ return origStat.call(this, p);
+ };
+
+ UploadManager = require('../lib/upload-manager');
+ });
+
+ it('emits progress events for each task', async () => {
+ const mgr = new UploadManager({});
+ const events = [];
+ mgr.on('progress', (data) => events.push(data));
+
+ await mgr.startBatch([
+ { file: '/test/video1.mp4', hoster: 'doodstream.com', apiKey: 'key1' }
+ ]);
+
+ const statuses = events.map(e => e.status);
+ assert.ok(statuses.includes('done'), 'should have done status');
+ assert.ok(events.length > 0, 'should emit at least one progress event');
+ });
+
+ it('replaces account pools and clears cached account state after an import', () => {
+ const mgr = new UploadManager({}, {}, {
+ 'byse.sx': [{ id: 'old', apiKey: 'old-key' }]
+ });
+ mgr.switchAccount('byse.sx', { id: 'fallback', apiKey: 'fallback-key' });
+ mgr._failedAccounts.set('byse.sx:old', true);
+ mgr._suspectSizeMemo.set('byse.sx:old', { size: 1, count: 2 });
+ mgr._suspectGoodAccounts.set('byse.sx', 'old');
+ mgr._doodApiKeyCache.set('old', 'cached-key');
+ mgr._baselineCache.set('byse.sx:old-key', Promise.resolve(new Set()));
+
+ mgr.replaceAccountPools({
+ 'byse.sx': [{ id: 'new', apiKey: 'new-key' }]
+ });
+
+ assert.deepEqual(mgr.accountPools['byse.sx'], [{ id: 'new', apiKey: 'new-key' }]);
+ assert.equal(mgr.getFailedAccountKeys().length, 0);
+ assert.equal(mgr.getOverride('byse.sx'), null);
+ assert.equal(mgr._suspectSizeMemo.size, 0);
+ assert.equal(mgr._suspectGoodAccounts.size, 0);
+ assert.equal(mgr._doodApiKeyCache.size, 0);
+ assert.equal(mgr._baselineCache.size, 0);
+ });
+
+ it('emits batch-done with correct summary', async () => {
+ const mgr = new UploadManager({});
+ let summary = null;
+ mgr.on('batch-done', (s) => { summary = s; });
+
+ await mgr.startBatch([
+ { file: '/test/video1.mp4', hoster: 'doodstream.com', apiKey: 'key1' },
+ { file: '/test/video2.mp4', hoster: 'doodstream.com', apiKey: 'key1' }
+ ]);
+
+ assert.ok(summary);
+ assert.equal(summary.total, 2);
+ assert.equal(summary.succeeded, 2);
+ assert.equal(summary.failed, 0);
+ assert.equal(summary.files.length, 2);
+ });
+
+ it('retries on failure then succeeds', async () => {
+ let callCount = 0;
+ mockUploadFile.mock.mockImplementation(async (hoster, filePath, apiKey, onProgress) => {
+ callCount++;
+ if (callCount <= 2) throw new Error('network error');
+ if (onProgress) onProgress(fakeFileSize, fakeFileSize);
+ return { download_url: 'https://test/ok', embed_url: null, file_code: 'ok' };
+ });
+
+ const mgr = new UploadManager({ 'doodstream.com': { retries: 3, parallelCount: 1, maxSpeedKbs: 0, restartBelowKbs: 0, timeIntervalSec: 0, maxSizeMb: 0 } });
+ const statuses = [];
+ mgr.on('progress', (d) => statuses.push(d.status));
+
+ await mgr.startBatch([
+ { file: '/test/video.mp4', hoster: 'doodstream.com', apiKey: 'key1' }
+ ]);
+
+ assert.ok(statuses.includes('retrying'), 'should show retrying status');
+ assert.ok(statuses.includes('done'), 'should eventually succeed');
+ assert.equal(callCount, 3);
+ });
+
+ it('exhausted retries result in error', async () => {
+ mockUploadFile.mock.mockImplementation(async () => {
+ throw new Error('permanent failure');
+ });
+
+ const mgr = new UploadManager({ 'doodstream.com': { retries: 1, parallelCount: 1, maxSpeedKbs: 0, restartBelowKbs: 0, timeIntervalSec: 0, maxSizeMb: 0 } });
+ let summary = null;
+ mgr.on('batch-done', (s) => { summary = s; });
+
+ await mgr.startBatch([
+ { file: '/test/video.mp4', hoster: 'doodstream.com', apiKey: 'key1' }
+ ]);
+
+ assert.ok(summary);
+ assert.equal(summary.failed, 1);
+ assert.equal(summary.succeeded, 0);
+ });
+
+ it('cancel aborts running uploads', async () => {
+ mockUploadFile.mock.mockImplementation(async (hoster, filePath, apiKey, onProgress, signal) => {
+ // Simulate a slow upload
+ await new Promise((resolve, reject) => {
+ const timer = setTimeout(() => resolve({ download_url: 'x', embed_url: null, file_code: 'x' }), 10000);
+ if (signal) signal.addEventListener('abort', () => { clearTimeout(timer); reject(new Error('Aborted')); });
+ });
+ });
+
+ const mgr = new UploadManager({});
+ let batchDone = false;
+ mgr.on('batch-done', () => { batchDone = true; });
+
+ const batchPromise = mgr.startBatch([
+ { file: '/test/video.mp4', hoster: 'doodstream.com', apiKey: 'key1' }
+ ]);
+
+ // Wait a bit then cancel
+ await new Promise(r => setTimeout(r, 100));
+ mgr.cancel();
+
+ await batchPromise;
+ assert.equal(mgr.running, false);
+ assert.ok(batchDone, 'batch-done should be emitted even after cancel');
+ });
+
+ it('maxSizeMb filter skips oversized files', async () => {
+ fakeFileSize = 5 * 1024 * 1024; // 5 MB
+
+ const mgr = new UploadManager({ 'doodstream.com': { retries: 0, parallelCount: 1, maxSpeedKbs: 0, restartBelowKbs: 0, timeIntervalSec: 0, maxSizeMb: 1 } });
+ const statuses = [];
+ mgr.on('progress', (d) => statuses.push(d.status));
+
+ await mgr.startBatch([
+ { file: '/test/big.mp4', hoster: 'doodstream.com', apiKey: 'key1' }
+ ]);
+
+ assert.ok(statuses.includes('skipped'), 'oversized file should be skipped');
+ assert.ok(!statuses.includes('uploading'), 'should not attempt upload');
+ });
+
+ it('per-hoster semaphore limits concurrency', async () => {
+ let concurrent = 0;
+ let maxConcurrent = 0;
+
+ mockUploadFile.mock.mockImplementation(async (hoster, filePath, apiKey, onProgress, signal) => {
+ concurrent++;
+ maxConcurrent = Math.max(maxConcurrent, concurrent);
+ await new Promise(r => setTimeout(r, 50));
+ concurrent--;
+ if (onProgress) onProgress(fakeFileSize, fakeFileSize);
+ return { download_url: 'https://test/ok', embed_url: null, file_code: 'ok' };
+ });
+
+ const mgr = new UploadManager({ 'doodstream.com': { retries: 0, parallelCount: 1, maxSpeedKbs: 0, restartBelowKbs: 0, timeIntervalSec: 0, maxSizeMb: 0 } });
+
+ await mgr.startBatch([
+ { file: '/test/a.mp4', hoster: 'doodstream.com', apiKey: 'k' },
+ { file: '/test/b.mp4', hoster: 'doodstream.com', apiKey: 'k' },
+ { file: '/test/c.mp4', hoster: 'doodstream.com', apiKey: 'k' }
+ ]);
+
+ assert.equal(maxConcurrent, 1, 'should only run 1 upload at a time');
+ });
+
+ it('global parallel limit caps concurrency across hosters', async () => {
+ let concurrent = 0;
+ let maxConcurrent = 0;
+
+ mockUploadFile.mock.mockImplementation(async (hoster, filePath, apiKey, onProgress) => {
+ concurrent++;
+ maxConcurrent = Math.max(maxConcurrent, concurrent);
+ await new Promise((resolve) => setTimeout(resolve, 40));
+ concurrent--;
+ if (onProgress) onProgress(fakeFileSize, fakeFileSize);
+ return { download_url: `https://${hoster}/ok`, embed_url: null, file_code: 'ok' };
+ });
+
+ const mgr = new UploadManager({
+ 'doodstream.com': { retries: 0, parallelCount: 5, maxSpeedKbs: 0, restartBelowKbs: 0, timeIntervalSec: 0, maxSizeMb: 0 },
+ 'voe.sx': { retries: 0, parallelCount: 5, maxSpeedKbs: 0, restartBelowKbs: 0, timeIntervalSec: 0, maxSizeMb: 0 },
+ 'vidmoly.me': { retries: 0, parallelCount: 5, maxSpeedKbs: 0, restartBelowKbs: 0, timeIntervalSec: 0, maxSizeMb: 0 }
+ }, {
+ parallelUploadCount: 2,
+ scaleParallelUploads: true
+ });
+
+ await mgr.startBatch([
+ { jobId: 'job-1', file: '/test/a.mp4', hoster: 'doodstream.com', apiKey: 'k' },
+ { jobId: 'job-2', file: '/test/b.mp4', hoster: 'voe.sx', apiKey: 'k' },
+ { jobId: 'job-3', file: '/test/c.mp4', hoster: 'vidmoly.me', apiKey: 'k' }
+ ]);
+
+ assert.equal(maxConcurrent, 2, 'should only run 2 uploads globally at once');
+ });
+
+ it('cancelJobs aborts a selected running upload', async () => {
+ mockUploadFile.mock.mockImplementation(async (hoster, filePath, apiKey, onProgress, signal) => {
+ await new Promise((resolve, reject) => {
+ const timer = setTimeout(() => resolve(), 250);
+ if (signal) {
+ signal.addEventListener('abort', () => {
+ clearTimeout(timer);
+ reject(new Error('Aborted'));
+ }, { once: true });
+ }
+ });
+ if (onProgress) onProgress(fakeFileSize, fakeFileSize);
+ return { download_url: 'https://test/ok', embed_url: null, file_code: 'ok' };
+ });
+
+ const mgr = new UploadManager({});
+ const statuses = [];
+ mgr.on('progress', (data) => statuses.push({ jobId: data.jobId, status: data.status }));
+
+ const batchPromise = mgr.startBatch([
+ { jobId: 'selected-job', file: '/test/video.mp4', hoster: 'doodstream.com', apiKey: 'key1' }
+ ]);
+
+ await new Promise((resolve) => setTimeout(resolve, 50));
+ mgr.cancelJobs(['selected-job']);
+
+ await batchPromise;
+ assert.ok(statuses.some((entry) => entry.jobId === 'selected-job' && entry.status === 'aborted'));
+ });
+
+ it('addJobs returns duplicate info and still runs newly queued jobs', async () => {
+ let releaseFirst = null;
+
+ mockUploadFile.mock.mockImplementation(async (hoster, filePath, apiKey, onProgress, signal) => {
+ if (filePath.endsWith('/first.mp4')) {
+ await new Promise((resolve, reject) => {
+ releaseFirst = resolve;
+ if (signal) {
+ signal.addEventListener('abort', () => reject(new Error('Aborted')), { once: true });
+ }
+ });
+ } else {
+ await new Promise((resolve) => setTimeout(resolve, 20));
+ }
+ if (onProgress) onProgress(fakeFileSize, fakeFileSize);
+ return { download_url: 'https://test/ok', embed_url: null, file_code: 'ok' };
+ });
+
+ const mgr = new UploadManager({
+ 'doodstream.com': { retries: 0, parallelCount: 1, maxSpeedKbs: 0, restartBelowKbs: 0, timeIntervalSec: 0, maxSizeMb: 0 }
+ });
+ const statuses = [];
+ mgr.on('progress', (data) => statuses.push({ jobId: data.jobId, status: data.status }));
+
+ const batchPromise = mgr.startBatch([
+ { jobId: 'job-first', file: '/test/first.mp4', hoster: 'doodstream.com', apiKey: 'key1' }
+ ]);
+
+ for (let i = 0; i < 50 && !releaseFirst; i++) {
+ await new Promise((resolve) => setTimeout(resolve, 10));
+ }
+ assert.equal(typeof releaseFirst, 'function', 'first job should be running before addJobs');
+
+ const addResult = mgr.addJobs([
+ { jobId: 'job-first', file: '/test/first.mp4', hoster: 'doodstream.com', apiKey: 'key1' },
+ { jobId: 'job-second', file: '/test/second.mp4', hoster: 'doodstream.com', apiKey: 'key1' },
+ { jobId: 'job-third', file: '/test/third.mp4', hoster: 'doodstream.com', apiKey: 'key1' }
+ ]);
+
+ assert.equal(addResult.added, 2);
+ assert.deepEqual(addResult.alreadyInBatchJobIds, ['job-first']);
+
+ releaseFirst();
+ await batchPromise;
+
+ assert.ok(statuses.some((entry) => entry.jobId === 'job-second' && entry.status === 'done'));
+ assert.ok(statuses.some((entry) => entry.jobId === 'job-third' && entry.status === 'done'));
+ });
+
+ it('_combineSignals propagates abort from either source', () => {
+ const mgr = new UploadManager({});
+ const ac1 = new AbortController();
+ const ac2 = new AbortController();
+
+ const { signal, cleanup } = mgr._combineSignals(ac1.signal, ac2.signal);
+ assert.equal(signal.aborted, false);
+
+ ac2.abort();
+ assert.equal(signal.aborted, true);
+ cleanup();
+ });
+
+ it('_combineSignals returns aborted signal if input already aborted', () => {
+ const mgr = new UploadManager({});
+ const ac1 = new AbortController();
+ ac1.abort();
+ const ac2 = new AbortController();
+
+ const { signal, cleanup } = mgr._combineSignals(ac1.signal, ac2.signal);
+ assert.equal(signal.aborted, true);
+ cleanup();
+ });
+
+ it('_sleep resolves after delay', async () => {
+ const mgr = new UploadManager({});
+ const start = Date.now();
+ await mgr._sleep(100);
+ assert.ok(Date.now() - start >= 90);
+ });
+
+ it('_sleep rejects on abort', async () => {
+ const mgr = new UploadManager({});
+ const ac = new AbortController();
+ setTimeout(() => ac.abort(), 10);
+ await assert.rejects(mgr._sleep(5000, ac.signal), /Aborted/);
+ });
+
+ it('file not found produces descriptive error', async () => {
+ // Override fs.promises.stat to throw ENOENT for a specific path
+ const fs = require('fs');
+ const origStat = fs.promises.stat;
+ fs.promises.stat = async function(p) {
+ if (p === '/test/deleted.mp4') throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+ return origStat.call(this, p);
+ };
+
+ const mgr = new UploadManager({});
+ const errors = [];
+ mgr.on('progress', (d) => { if (d.error) errors.push(d.error); });
+
+ await mgr.startBatch([
+ { file: '/test/deleted.mp4', hoster: 'doodstream.com', apiKey: 'key1' }
+ ]);
+
+ fs.promises.stat = origStat;
+ assert.ok(errors.some(e => e.includes('nicht gefunden')), `expected "nicht gefunden" error, got: ${errors.join(', ')}`);
+ });
+
+ it('zero-byte file produces descriptive error', async () => {
+ fakeFileSize = 0;
+
+ const mgr = new UploadManager({});
+ const errors = [];
+ mgr.on('progress', (d) => { if (d.error) errors.push(d.error); });
+
+ await mgr.startBatch([
+ { file: '/test/empty.mp4', hoster: 'doodstream.com', apiKey: 'key1' }
+ ]);
+
+ assert.ok(errors.some(e => e.includes('0 Bytes')), `expected "0 Bytes" error, got: ${errors.join(', ')}`);
+ });
+
+ it('empty batch completes immediately with zero counts', async () => {
+ const mgr = new UploadManager({});
+ let summary = null;
+ mgr.on('batch-done', (s) => { summary = s; });
+
+ const start = Date.now();
+ await mgr.startBatch([]);
+ const elapsed = Date.now() - start;
+
+ assert.ok(summary, 'batch-done should be emitted');
+ assert.equal(summary.total, 0);
+ assert.equal(summary.succeeded, 0);
+ assert.equal(summary.failed, 0);
+ assert.ok(elapsed < 200, `empty batch should complete fast, took ${elapsed}ms`);
+ });
+
+ it('scaleParallelUploads limits per-hoster count to global limit', async () => {
+ let concurrent = 0;
+ let maxConcurrent = 0;
+
+ mockUploadFile.mock.mockImplementation(async (hoster, filePath, apiKey, onProgress) => {
+ concurrent++;
+ maxConcurrent = Math.max(maxConcurrent, concurrent);
+ await new Promise(r => setTimeout(r, 40));
+ concurrent--;
+ if (onProgress) onProgress(fakeFileSize, fakeFileSize);
+ return { download_url: 'ok', embed_url: null, file_code: 'ok' };
+ });
+
+ const mgr = new UploadManager(
+ { 'doodstream.com': { retries: 0, parallelCount: 10, maxSpeedKbs: 0, restartBelowKbs: 0, timeIntervalSec: 0, maxSizeMb: 0 } },
+ { parallelUploadCount: 2, scaleParallelUploads: true }
+ );
+
+ await mgr.startBatch([
+ { file: '/test/a.mp4', hoster: 'doodstream.com', apiKey: 'k' },
+ { file: '/test/b.mp4', hoster: 'doodstream.com', apiKey: 'k' },
+ { file: '/test/c.mp4', hoster: 'doodstream.com', apiKey: 'k' },
+ { file: '/test/d.mp4', hoster: 'doodstream.com', apiKey: 'k' },
+ { file: '/test/e.mp4', hoster: 'doodstream.com', apiKey: 'k' }
+ ]);
+
+ assert.ok(maxConcurrent <= 2, `scaleParallelUploads should cap at 2, was ${maxConcurrent}`);
+ });
+
+ it('addJobs injects new tasks into running batch', async () => {
+ let started = 0;
+ mockUploadFile.mock.mockImplementation(async (hoster, filePath, apiKey, onProgress) => {
+ started++;
+ await new Promise(r => setTimeout(r, 100));
+ if (onProgress) onProgress(fakeFileSize, fakeFileSize);
+ return { download_url: 'ok', embed_url: null, file_code: 'ok' };
+ });
+
+ const mgr = new UploadManager({});
+ let summary = null;
+ mgr.on('batch-done', (s) => { summary = s; });
+
+ // Start batch with 2 tasks
+ const batchPromise = mgr.startBatch([
+ { jobId: 'job-1', file: '/test/a.mp4', hoster: 'doodstream.com', apiKey: 'k' },
+ { jobId: 'job-2', file: '/test/b.mp4', hoster: 'doodstream.com', apiKey: 'k' }
+ ]);
+
+ // After 30ms (during upload), inject 2 more tasks
+ await new Promise(r => setTimeout(r, 30));
+ const result = mgr.addJobs([
+ { jobId: 'job-3', file: '/test/c.mp4', hoster: 'doodstream.com', apiKey: 'k' },
+ { jobId: 'job-4', file: '/test/d.mp4', hoster: 'doodstream.com', apiKey: 'k' }
+ ]);
+ assert.equal(result.added, 2, 'should add 2 new jobs');
+ assert.equal(result.alreadyInBatchJobIds.length, 0);
+
+ await batchPromise;
+ assert.ok(summary);
+ assert.equal(started, 4, 'all 4 jobs should have run');
+ });
+
+ it('addJobs rejects duplicates already in running batch', async () => {
+ mockUploadFile.mock.mockImplementation(async (hoster, filePath, apiKey, onProgress, signal) => {
+ // Slow upload so we can add jobs while it's running
+ await new Promise((resolve, reject) => {
+ const timer = setTimeout(resolve, 200);
+ if (signal) signal.addEventListener('abort', () => { clearTimeout(timer); reject(new Error('Aborted')); });
+ });
+ if (onProgress) onProgress(fakeFileSize, fakeFileSize);
+ return { download_url: 'ok', embed_url: null, file_code: 'ok' };
+ });
+
+ const mgr = new UploadManager({});
+ const batchPromise = mgr.startBatch([
+ { jobId: 'job-A', file: '/test/x.mp4', hoster: 'doodstream.com', apiKey: 'k' }
+ ]);
+
+ // Try to add the SAME jobId while it's running
+ await new Promise(r => setTimeout(r, 50));
+ const result = mgr.addJobs([
+ { jobId: 'job-A', file: '/test/x.mp4', hoster: 'doodstream.com', apiKey: 'k' },
+ { jobId: 'job-B', file: '/test/y.mp4', hoster: 'doodstream.com', apiKey: 'k' }
+ ]);
+ assert.equal(result.added, 1, 'should skip duplicate jobId, add only the new one');
+ assert.deepEqual(result.alreadyInBatchJobIds, ['job-A']);
+
+ await batchPromise;
+ });
+
+ it('addJobs returns added=0 when not running', () => {
+ const mgr = new UploadManager({});
+ const result = mgr.addJobs([
+ { jobId: 'job-1', file: '/test/a.mp4', hoster: 'doodstream.com', apiKey: 'k' }
+ ]);
+ assert.equal(result.added, 0);
+ });
+
+ it('stats event contains expected fields', async () => {
+ // Make upload take long enough for stats interval to fire
+ mockUploadFile.mock.mockImplementation(async (hoster, filePath, apiKey, onProgress, signal) => {
+ await new Promise(r => setTimeout(r, 1500));
+ if (onProgress) onProgress(fakeFileSize, fakeFileSize);
+ return { download_url: 'https://test/ok', embed_url: null, file_code: 'ok' };
+ });
+
+ const mgr = new UploadManager({});
+ const statsEvents = [];
+ mgr.on('stats', (d) => statsEvents.push(d));
+
+ await mgr.startBatch([
+ { file: '/test/video.mp4', hoster: 'doodstream.com', apiKey: 'key1' }
+ ]);
+
+ assert.ok(statsEvents.length > 0, 'should have received stats events');
+ const stat = statsEvents[0];
+ assert.ok('globalSpeedKbs' in stat);
+ assert.ok('totalBytes' in stat);
+ assert.ok('elapsed' in stat);
+ assert.ok('activeJobs' in stat);
+ });
+
+ describe('error classification', () => {
+ it('treats "not enough disk space" as account-level, not file-rejected', () => {
+ const mgr = new UploadManager({});
+ // Shape matches what lib/hosters.js attaches for byse account-storage-full
+ const err = new Error('Byse lehnte Datei ab: 0:0:0:not enough disk space on your account');
+ err.accountError = true;
+ assert.equal(mgr._isFileRejectedError(err), false,
+ 'account-level error must NOT be classified as file-rejected');
+ assert.equal(mgr._shouldSkipRetryOnAccountError(err), true,
+ 'account-storage-full must trigger account rotation');
+ });
+
+ it('classifies disk-space errors by message alone (safety net)', () => {
+ const mgr = new UploadManager({});
+ const err = new Error('Byse lehnte Datei ab: not enough disk space');
+ // No flag set — regex alone must catch it.
+ assert.equal(mgr._shouldSkipRetryOnAccountError(err), true);
+ assert.equal(mgr._isFileRejectedError(err), false,
+ 'must not match generic "lehnte Datei ab" as file-rejected');
+ });
+
+ it('keeps true file rejections as file-rejected', () => {
+ const mgr = new UploadManager({});
+ const err = new Error('Byse lehnte Datei ab: Duplicate');
+ err.fileRejected = true;
+ assert.equal(mgr._isFileRejectedError(err), true);
+ assert.equal(mgr._shouldSkipRetryOnAccountError(err), false);
+ });
+
+ it('file-rejected regex still matches known phrases without flag', () => {
+ const mgr = new UploadManager({});
+ for (const msg of [
+ 'Not video file format',
+ 'Duplicate',
+ 'Datei zu klein',
+ 'File too large',
+ 'Invalid file'
+ ]) {
+ assert.equal(mgr._isFileRejectedError(new Error(msg)), true, `should match: ${msg}`);
+ }
+ });
+
+ it('accountError flag beats fileRejected if both set (defensive)', () => {
+ const mgr = new UploadManager({});
+ const err = new Error('weird');
+ err.fileRejected = true;
+ err.accountError = true;
+ assert.equal(mgr._isFileRejectedError(err), false,
+ 'account-level always wins — rotation must happen');
+ assert.equal(mgr._shouldSkipRetryOnAccountError(err), true);
+ });
+ });
+
+ describe('session-level account memory', () => {
+ // Scenario: user has 2 byse accounts. Account 1 is full ("not enough
+ // disk space"). First job fails on acc1 → rotation to acc2. Second job
+ // must NOT re-probe acc1; pre-job-swap has to kick in.
+ it('after account is marked failed, next job swaps straight to override without retrying acc1', async () => {
+ // Only acc1 throws disk-space; acc2 succeeds. Mock decides by apiKey.
+ mockUploadFile.mock.mockImplementation(async (hoster, filePath, apiKey, onProgress) => {
+ if (apiKey === 'acc1-key') {
+ const err = new Error('Byse lehnte Datei ab: 0:0:0:not enough disk space on your account');
+ err.accountError = true;
+ throw err;
+ }
+ if (onProgress) onProgress(fakeFileSize, fakeFileSize);
+ return { download_url: 'https://byse.sx/ok', embed_url: null, file_code: 'ok' };
+ });
+
+ const mgr = new UploadManager(
+ { 'byse.sx': { retries: 3, parallelCount: 1, maxSpeedKbs: 0, restartBelowKbs: 0, timeIntervalSec: 0, maxSizeMb: 0 } }
+ );
+
+ // Simulate main.js: on account-failed, resolve fallback → switchAccount
+ mgr.on('account-failed', ({ hoster, accountId }) => {
+ mgr.switchAccount(hoster, { id: 'acc2', username: 'u2', password: 'p2', apiKey: 'acc2-key' });
+ });
+
+ const rotEvents = [];
+ mgr.on('rot-log', (e) => rotEvents.push(e));
+ const progress = [];
+ mgr.on('progress', (d) => progress.push({ fileName: d.fileName, status: d.status, error: d.error }));
+
+ await mgr.startBatch([
+ { file: '/test/a.mp4', hoster: 'byse.sx', apiKey: 'acc1-key', accountId: 'acc1', username: 'u1', password: 'p1' },
+ { file: '/test/b.mp4', hoster: 'byse.sx', apiKey: 'acc1-key', accountId: 'acc1', username: 'u1', password: 'p1' }
+ ]);
+
+ // Event sequence we expect:
+ // - job A: fast-fail on acc1 → mark-failed → switchAccount → rotate → upload with acc2 → done
+ // - job B: pre-job-swap from acc1 → acc2 (no attempts on acc1!) → done
+ const events = rotEvents.map(e => e.event);
+ assert.ok(events.includes('fast-fail'), `expected fast-fail, got: ${events.join(',')}`);
+ assert.ok(events.includes('mark-failed'), `expected mark-failed, got: ${events.join(',')}`);
+ assert.ok(events.includes('switchAccount'), `expected switchAccount, got: ${events.join(',')}`);
+ assert.ok(events.includes('pre-job-swap'), `expected pre-job-swap for 2nd job, got: ${events.join(',')}`);
+
+ // job B's pre-job-swap MUST predate any upload attempt for /test/b.mp4.
+ // If acc1 was probed for B, the mock would have thrown and we'd see
+ // another fast-fail or retrying event for b.mp4.
+ const bProgressErrors = progress
+ .filter(p => p.fileName && p.fileName.includes('b.mp4') && p.error)
+ .map(p => p.error);
+ assert.equal(bProgressErrors.length, 0,
+ `job B should never have touched acc1; got errors: ${bProgressErrors.join(' | ')}`);
+
+ // Both jobs should be done at the end.
+ const doneFiles = progress.filter(p => p.status === 'done').map(p => p.fileName);
+ assert.ok(doneFiles.some(f => f && f.includes('a.mp4')), 'a.mp4 should finish via rotation');
+ assert.ok(doneFiles.some(f => f && f.includes('b.mp4')), 'b.mp4 should finish via pre-job-swap');
+
+ // Sanity: mock was called with acc2-key more often than acc1-key.
+ const byKey = { acc1: 0, acc2: 0 };
+ for (const call of mockUploadFile.mock.calls) {
+ if (call.arguments[2] === 'acc1-key') byKey.acc1++;
+ else if (call.arguments[2] === 'acc2-key') byKey.acc2++;
+ }
+ assert.ok(byKey.acc1 <= 1, `acc1 should only be tried once (for job A); got ${byKey.acc1}`);
+ assert.ok(byKey.acc2 >= 2, `acc2 should handle both jobs after rotation; got ${byKey.acc2}`);
+ });
+
+ it('on fresh UploadManager (simulates app restart), failed-account memory is gone', () => {
+ const mgr1 = new UploadManager({});
+ mgr1._failedAccounts.set('byse.sx:acc1', true);
+ mgr1.switchAccount('byse.sx', { id: 'acc2' });
+ assert.equal(mgr1._failedAccounts.size, 1);
+ assert.equal(mgr1._accountOverrides.size, 1);
+
+ const mgr2 = new UploadManager({});
+ assert.equal(mgr2._failedAccounts.size, 0, 'new manager must start clean');
+ assert.equal(mgr2._accountOverrides.size, 0, 'override map must be empty on fresh manager');
+ });
+
+ it('exposes failed-account introspection (for main.js mid-batch re-resolve)', () => {
+ const mgr = new UploadManager({});
+ assert.deepEqual(mgr.getFailedAccountKeys(), []);
+ assert.equal(mgr.getOverride('byse.sx'), null);
+
+ mgr._failedAccounts.set('byse.sx:acc1', true);
+ mgr._failedAccounts.set('voe.sx:other', true);
+ assert.deepEqual(mgr.getFailedAccountKeys().sort(), ['byse.sx:acc1', 'voe.sx:other']);
+ assert.equal(mgr.getOverride('byse.sx'), null, 'no override yet');
+
+ mgr.switchAccount('byse.sx', { id: 'acc2', apiKey: 'k2' });
+ assert.equal(mgr.getOverride('byse.sx').id, 'acc2');
+ assert.equal(mgr.getOverride('voe.sx'), null, 'unrelated hoster still has no override');
+ });
+
+ it('startBatch primes failed-accounts + overrides — retry after batch-done skips dead account', async () => {
+ // acc1 fails with disk-space; acc2 succeeds.
+ mockUploadFile.mock.mockImplementation(async (hoster, filePath, apiKey, onProgress) => {
+ if (apiKey === 'acc1-key') {
+ const err = new Error('Byse lehnte Datei ab: not enough disk space');
+ err.accountError = true;
+ throw err;
+ }
+ if (onProgress) onProgress(fakeFileSize, fakeFileSize);
+ return { download_url: 'ok', embed_url: null, file_code: 'ok' };
+ });
+
+ const mgr = new UploadManager(
+ { 'byse.sx': { retries: 3, parallelCount: 1, maxSpeedKbs: 0, restartBelowKbs: 0, timeIntervalSec: 0, maxSizeMb: 0 } }
+ );
+ const rotEvents = [];
+ mgr.on('rot-log', (e) => rotEvents.push(e));
+
+ // Simulate a retry-after-batch-done: main.js would pass the
+ // session-cached failed-accounts + overrides from the previous batch.
+ await mgr.startBatch([
+ { file: '/test/a.mp4', hoster: 'byse.sx', apiKey: 'acc1-key', accountId: 'acc1', username: 'u1', password: 'p1' }
+ ], {
+ primeFailedAccounts: ['byse.sx:acc1'],
+ primeOverrides: [['byse.sx', { id: 'acc2', username: 'u2', password: 'p2', apiKey: 'acc2-key' }]]
+ });
+
+ const events = rotEvents.map(e => e.event);
+ // pre-job-swap should fire on the very first attempt — no fast-fail
+ // because acc1 was never touched.
+ assert.ok(events.includes('pre-job-swap'),
+ `expected pre-job-swap from primed state; got: ${events.join(',')}`);
+ assert.ok(!events.includes('fast-fail'),
+ `must NOT burn a fast-fail on primed-dead acc1; got: ${events.join(',')}`);
+ assert.ok(!events.includes('mark-failed'),
+ `acc1 was already marked failed (primed); must not emit mark-failed again; got: ${events.join(',')}`);
+
+ // acc1 must not be touched at all.
+ const acc1Calls = mockUploadFile.mock.calls.filter(c => c.arguments[2] === 'acc1-key').length;
+ assert.equal(acc1Calls, 0, 'primed-dead acc1 must not receive any upload attempts');
+ });
+
+ it('generic error + pre-resolved override: rotates after 1 attempt (no more 5x on primary)', async () => {
+ // acc1 throws a generic non-transient, non-account-specific error.
+ // acc2 succeeds. With a pre-resolved override (from main.js at batch
+ // start), the retry loop must break after 1 attempt on acc1 and rotate.
+ let acc1Calls = 0;
+ let acc2Calls = 0;
+ mockUploadFile.mock.mockImplementation(async (hoster, filePath, apiKey, onProgress) => {
+ if (apiKey === 'acc1-key') {
+ acc1Calls++;
+ throw new Error('VOE Upload: irgendein generischer Fehler');
+ }
+ acc2Calls++;
+ if (onProgress) onProgress(fakeFileSize, fakeFileSize);
+ return { download_url: 'ok', embed_url: null, file_code: 'ok' };
+ });
+
+ const mgr = new UploadManager(
+ { 'voe.sx': { retries: 5, parallelCount: 1, maxSpeedKbs: 0, restartBelowKbs: 0, timeIntervalSec: 0, maxSizeMb: 0 } }
+ );
+ const events = [];
+ mgr.on('rot-log', (e) => events.push(e.event));
+
+ await mgr.startBatch([
+ { file: '/test/a.mp4', hoster: 'voe.sx', apiKey: 'acc1-key', accountId: 'acc1' }
+ ], {
+ // Main.js pre-resolves the fallback at batch start.
+ primeOverrides: [['voe.sx', { id: 'acc2', apiKey: 'acc2-key' }]]
+ });
+
+ assert.equal(acc1Calls, 1, 'acc1 must get exactly 1 attempt before rotation kicks in');
+ assert.ok(acc2Calls >= 1, 'acc2 must take over');
+ assert.ok(events.includes('try-alternate-after-fail'),
+ `expected try-alternate-after-fail; got: ${events.join(',')}`);
+ });
+
+ it('transient error + pre-resolved override: retries SAME acc (network, not acc, is the issue)', async () => {
+ let acc1Calls = 0;
+ let acc2Calls = 0;
+ mockUploadFile.mock.mockImplementation(async (hoster, filePath, apiKey, onProgress) => {
+ if (apiKey === 'acc1-key') {
+ acc1Calls++;
+ if (acc1Calls <= 2) throw new Error('connect ECONNRESET 1.2.3.4:443');
+ if (onProgress) onProgress(fakeFileSize, fakeFileSize);
+ return { download_url: 'ok-on-acc1-retry', embed_url: null, file_code: 'ok' };
+ }
+ acc2Calls++;
+ if (onProgress) onProgress(fakeFileSize, fakeFileSize);
+ return { download_url: 'ok', embed_url: null, file_code: 'ok' };
+ });
+
+ const mgr = new UploadManager(
+ { 'voe.sx': { retries: 5, parallelCount: 1, maxSpeedKbs: 0, restartBelowKbs: 0, timeIntervalSec: 0, maxSizeMb: 0 } }
+ );
+ const events = [];
+ mgr.on('rot-log', (e) => events.push(e.event));
+
+ await mgr.startBatch([
+ { file: '/test/a.mp4', hoster: 'voe.sx', apiKey: 'acc1-key', accountId: 'acc1' }
+ ], {
+ primeOverrides: [['voe.sx', { id: 'acc2', apiKey: 'acc2-key' }]]
+ });
+
+ assert.equal(acc1Calls, 3, 'transient must retry same acc until success');
+ assert.equal(acc2Calls, 0, 'must NOT rotate away on transient network errors');
+ assert.ok(!events.includes('try-alternate-after-fail'),
+ `transient should NOT trigger try-alternate-after-fail; got: ${events.join(',')}`);
+ });
+
+ it('generic error + NO override: falls back to classic retry on same account', async () => {
+ let acc1Calls = 0;
+ mockUploadFile.mock.mockImplementation(async (hoster, filePath, apiKey, onProgress) => {
+ acc1Calls++;
+ throw new Error('something generic');
+ });
+
+ const mgr = new UploadManager(
+ { 'voe.sx': { retries: 3, parallelCount: 1, maxSpeedKbs: 0, restartBelowKbs: 0, timeIntervalSec: 0, maxSizeMb: 0 } }
+ );
+
+ await mgr.startBatch([
+ { file: '/test/a.mp4', hoster: 'voe.sx', apiKey: 'acc1-key', accountId: 'acc1' }
+ ]);
+
+ // retries=3 → maxAttempts=4 (retries + 1). Without an override to rotate
+ // to, must exhaust all 4 attempts on acc1.
+ assert.equal(acc1Calls, 4, 'single-account hoster must retry N+1 times on same account');
+ });
+
+ it('startBatch without prime opts still clears state (back-compat)', async () => {
+ const mgr = new UploadManager({});
+ mgr._failedAccounts.set('byse.sx:acc1', true);
+ mgr._accountOverrides.set('byse.sx', { id: 'leftover' });
+
+ mockUploadFile.mock.mockImplementation(async (hoster, filePath, apiKey, onProgress) => {
+ if (onProgress) onProgress(fakeFileSize, fakeFileSize);
+ return { download_url: 'ok', embed_url: null, file_code: 'ok' };
+ });
+
+ await mgr.startBatch([
+ { file: '/test/a.mp4', hoster: 'doodstream.com', apiKey: 'k' }
+ ]);
+
+ assert.equal(mgr._failedAccounts.size, 0, 'legacy callers still get a clean slate');
+ assert.equal(mgr._accountOverrides.size, 0, 'legacy callers still get a clean slate for overrides');
+ });
+
+ it('transient network errors skip rotation (account stays fine)', () => {
+ const mgr = new UploadManager({});
+ const cases = [
+ 'getaddrinfo ENOTFOUND api.byse.sx',
+ 'connect ECONNRESET 104.18.10.10:443',
+ 'connect ETIMEDOUT 1.2.3.4:443',
+ 'socket hang up',
+ 'request to https://voe.sx failed, reason: getaddrinfo EAI_AGAIN',
+ 'fetch failed',
+ 'connect ECONNREFUSED 127.0.0.1:443',
+ 'network error'
+ ];
+ for (const msg of cases) {
+ const err = new Error(msg);
+ assert.equal(mgr._isTransientNetworkError(err), true, `should mark transient: ${msg}`);
+ assert.equal(mgr._isFileRejectedError(err), false, `transient must NOT be file-rejected: ${msg}`);
+ assert.equal(mgr._shouldSkipRetryOnAccountError(err), false, `transient must NOT be account-specific: ${msg}`);
+ }
+ });
+
+ it('transient classification does not swallow real account failures', () => {
+ const mgr = new UploadManager({});
+ const notTransient = [
+ 'HTTP 429 Too Many Requests',
+ 'quota exceeded',
+ 'account suspended',
+ 'Byse lehnte Datei ab: Duplicate',
+ 'Falscher Passwort',
+ 'Session expired'
+ ];
+ for (const msg of notTransient) {
+ const err = new Error(msg);
+ assert.equal(mgr._isTransientNetworkError(err), false,
+ `must NOT be transient: "${msg}"`);
+ }
+ });
+
+ it('hoster-transient flag is recognised (primary path)', () => {
+ const mgr = new UploadManager({});
+ const err = new Error('whatever');
+ err.hosterTransient = true;
+ assert.equal(mgr._isHosterTransientError(err), true);
+ // Must not be confused with other classes.
+ assert.equal(mgr._isFileRejectedError(err), false);
+ assert.equal(mgr._isTransientNetworkError(err), false);
+ assert.equal(mgr._shouldSkipRetryOnAccountError(err), false);
+ });
+
+ it('transientNetwork flag is recognised even with an empty/absent message', () => {
+ const mgr = new UploadManager({});
+ const flagged = new Error('');
+ flagged.transientNetwork = true;
+ assert.equal(mgr._isTransientNetworkError(flagged), true, 'flag must win before the empty-message guard');
+ assert.equal(mgr._isFileRejectedError(flagged), false);
+ assert.equal(mgr._isHosterTransientError(flagged), false);
+ assert.equal(mgr._shouldSkipRetryOnAccountError(flagged), false);
+
+ const flaggedHtml = new Error('Upload-Antwort von byse.sx war kein JSON (HTTP 502): forbidden duplicate');
+ flaggedHtml.transientNetwork = true;
+ assert.equal(mgr._isTransientNetworkError(flaggedHtml), true);
+ assert.equal(mgr._shouldSkipRetryOnAccountError(flaggedHtml), false, 'flag overrides any account-keyword in the 502 HTML snippet');
+ assert.equal(mgr._isFileRejectedError(flaggedHtml), false, 'flag overrides any rejection-keyword in the 502 HTML snippet');
+ });
+
+ it('5xx / gateway errors classify transient by message (defensive fallback), 4xx stay account-level', () => {
+ const mgr = new UploadManager({});
+ const transient = [
+ 'Upload-Antwort von byse.sx war kein JSON (HTTP 502): ',
+ 'Upload fehlgeschlagen (HTTP 503, text/html)',
+ 'HTTP 504 Gateway Time-out',
+ 'Bad Gateway',
+ 'Service Unavailable'
+ ];
+ for (const msg of transient) {
+ assert.equal(mgr._isTransientNetworkError(new Error(msg)), true, `should be transient: ${msg}`);
+ }
+ const accountLevel = [
+ 'Upload fehlgeschlagen (HTTP 429, application/json)',
+ 'HTTP 403 Forbidden',
+ 'HTTP 401 Unauthorized'
+ ];
+ for (const msg of accountLevel) {
+ assert.equal(mgr._isTransientNetworkError(new Error(msg)), false, `must NOT be transient: ${msg}`);
+ assert.equal(mgr._shouldSkipRetryOnAccountError(new Error(msg)), true, `must stay account-level: ${msg}`);
+ }
+ });
+
+ it('hoster-transient regex fallback catches wrapped doodstream empty-form errors', () => {
+ const mgr = new UploadManager({});
+ const cases = [
+ 'Doodstream Upload: kein Filecode — Server gab leeren Link zurueck (st=?, fn=fehlt/leer ...)',
+ 'wrapper: Server gab leeren Link zurueck while parsing'
+ ];
+ for (const msg of cases) {
+ assert.equal(mgr._isHosterTransientError(new Error(msg)), true, `should match: ${msg}`);
+ }
+ // Plain network and account errors must NOT match the hoster-transient class.
+ const negatives = [
+ 'fetch failed',
+ 'getaddrinfo ENOTFOUND',
+ 'HTTP 429',
+ 'quota exceeded',
+ 'Byse lehnte Datei ab: Duplicate'
+ ];
+ for (const msg of negatives) {
+ assert.equal(mgr._isHosterTransientError(new Error(msg)), false, `must NOT match: ${msg}`);
+ }
+ });
+
+ it('regression: hoster-transient does NOT blacklist the account (account stays usable across batches)', async () => {
+ // Simulate doodstream-upload throwing the tagged empty-form error.
+ mockUploadFile.mock.mockImplementation(async () => {
+ const err = new Error('Doodstream Upload: kein Filecode — Server gab leeren Link zurueck (st=?, fn=fehlt/leer ...)');
+ err.hosterTransient = true;
+ throw err;
+ });
+
+ const mgr = new UploadManager(
+ { 'doodstream.com': { retries: 3, parallelCount: 1, maxSpeedKbs: 0, restartBelowKbs: 0, timeIntervalSec: 0, maxSizeMb: 0 } }
+ );
+ const rotEvents = [];
+ mgr.on('rot-log', (e) => rotEvents.push(e));
+
+ // No username/password so the manager routes through the mocked
+ // hosters.uploadFile (instead of DoodstreamUploader directly).
+ await mgr.startBatch([
+ { file: '/test/Arrested.Development.mkv', hoster: 'doodstream.com', apiKey: 'acc1-key', accountId: 'acc1' }
+ ]);
+
+ const events = rotEvents.map(e => e.event);
+ // Must NOT poison the account — that's the entire point of this fix.
+ assert.equal(mgr._failedAccounts.size, 0, `account must NOT be blacklisted; _failedAccounts=${JSON.stringify(mgr.getFailedAccountKeys())}`);
+ assert.ok(!events.includes('mark-failed'), `must NOT mark-failed for hoster-transient; got: ${events.join(',')}`);
+ // The in-loop fast-break and the post-loop classification must both fire.
+ assert.ok(events.includes('hoster-transient'),
+ `expected hoster-transient (in-loop break, no wasted retries); got: ${events.join(',')}`);
+ assert.ok(events.includes('skip-rotation-hoster-transient'),
+ `expected skip-rotation-hoster-transient (post-loop branch); got: ${events.join(',')}`);
+ // And the retry loop must NOT burn the full retries=3 -> only 1 attempt on this account.
+ assert.equal(mockUploadFile.mock.calls.length, 1,
+ `must fail fast on hoster-transient, not re-upload the file 4× wasting bandwidth; got ${mockUploadFile.mock.calls.length} calls`);
+ });
+
+ it('late-resolved override is honored by subsequent jobs (simulates mid-batch config add)', async () => {
+ // Only acc1 throws; acc2 succeeds.
+ mockUploadFile.mock.mockImplementation(async (hoster, filePath, apiKey, onProgress) => {
+ if (apiKey === 'acc1-key') {
+ const err = new Error('Byse lehnte Datei ab: not enough disk space');
+ err.accountError = true;
+ throw err;
+ }
+ if (onProgress) onProgress(fakeFileSize, fakeFileSize);
+ return { download_url: 'ok', embed_url: null, file_code: 'ok' };
+ });
+
+ const mgr = new UploadManager(
+ { 'byse.sx': { retries: 1, parallelCount: 1, maxSpeedKbs: 0, restartBelowKbs: 0, timeIntervalSec: 0, maxSizeMb: 0 } }
+ );
+
+ // Scenario: initially config has ONLY acc1. No account-failed listener
+ // resolves a fallback (because none exists in config yet). Job A fails
+ // with rotation-end.
+ const rotEvents = [];
+ mgr.on('rot-log', (e) => rotEvents.push(e));
+
+ await mgr.startBatch([
+ { file: '/test/a.mp4', hoster: 'byse.sx', apiKey: 'acc1-key', accountId: 'acc1', username: 'u1', password: 'p1' }
+ ]);
+
+ // Job A should have ended with rotation-end (no fallback available).
+ const eventsA = rotEvents.map(e => e.event);
+ assert.ok(eventsA.includes('mark-failed'), 'acc1 must be marked failed');
+ assert.ok(eventsA.includes('rotation-end'), 'expected rotation-end without a fallback');
+ assert.equal(mgr.getFailedAccountKeys().length, 1);
+ assert.equal(mgr.getOverride('byse.sx'), null, 'no override set during first batch');
+
+ // --- Simulate: user adds acc2 in Settings → save-config handler finds
+ // that byse.sx:acc1 is failed without an override → resolves + switches.
+ mgr.switchAccount('byse.sx', { id: 'acc2', username: 'u2', password: 'p2', apiKey: 'acc2-key' });
+
+ // Now a follow-up batch (same running session — in production, addJobs
+ // or a new startBatch without clearing maps would reach this state).
+ // We need to ALSO clear _failedAccounts manually here because startBatch
+ // resets it — so we poke the inner state to emulate "still mid-batch
+ // with late config". The switchAccount-after-fail path is what matters.
+ rotEvents.length = 0;
+ // Re-run just the _runJob path by manually setting up state and using
+ // addJobs — simulates mid-batch job add after config change.
+ mgr.running = true;
+ mgr._batchResults = new Map();
+ mgr._batchResults.set('/test/b.mp4', { name: 'b.mp4', size: fakeFileSize, results: [] });
+ mgr._failedAccounts.set('byse.sx:acc1', true); // re-establish failed state
+ mgr._additionalPromises = [];
+
+ // Spawn a new job through addJobs() path (uses _runJob internally)
+ const addResult = await mgr.addJobs([
+ { file: '/test/b.mp4', hoster: 'byse.sx', apiKey: 'acc1-key', accountId: 'acc1', username: 'u1', password: 'p1', jobId: 'jb' }
+ ]);
+ assert.ok(addResult.added >= 1 || addResult.alreadyInBatch === 0,
+ `addJobs should accept new job: ${JSON.stringify(addResult)}`);
+ await Promise.allSettled(mgr._additionalPromises);
+
+ const eventsB = rotEvents.map(e => e.event);
+ assert.ok(eventsB.includes('pre-job-swap'),
+ `job B should have pre-job-swap after late override was set; got: ${eventsB.join(',')}`);
+
+ // Mock must have been called with acc2-key for the new job (not acc1-key again)
+ const acc1ForB = mockUploadFile.mock.calls.filter(c =>
+ c.arguments[1] === '/test/b.mp4' && c.arguments[2] === 'acc1-key').length;
+ assert.equal(acc1ForB, 0, 'job B must never touch acc1-key after late fallback was set');
+ });
+ });
+});
diff --git a/tests/validate-credentials.test.js b/tests/validate-credentials.test.js
new file mode 100644
index 0000000..f28f70b
--- /dev/null
+++ b/tests/validate-credentials.test.js
@@ -0,0 +1,208 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const {
+ createAccountSubmitter,
+ getAccountSubmitLabel,
+ submitValidatedAccount
+} = require('../renderer/account-submit');
+
+test('account submit labels stay exact for add, edit, and OTP retries', () => {
+ assert.equal(getAccountSubmitLabel({ isEdit: false, hasOtp: false }), 'Prüfen und speichern');
+ assert.equal(getAccountSubmitLabel({ isEdit: true, hasOtp: false }), 'Prüfen und speichern');
+ assert.equal(getAccountSubmitLabel({ isEdit: false, hasOtp: true }), 'Prüfen und speichern');
+ assert.equal(getAccountSubmitLabel({ isEdit: true, hasOtp: true }), 'Prüfen und speichern');
+});
+
+test('close and reopen cannot start a second save while the first save is pending', async () => {
+ const submitter = createAccountSubmitter();
+ let current = true;
+ let commits = 0;
+ let applies = 0;
+ let saveStarted;
+ let finishSave;
+ const started = new Promise(resolve => { saveStarted = resolve; });
+ const saving = new Promise(resolve => { finishSave = resolve; });
+ const first = submitter.submit({
+ validate: async () => ({ status: 'ok' }),
+ commit: async () => {
+ commits++;
+ saveStarted();
+ await saving;
+ return { accountId: 'first' };
+ },
+ afterCommit: async () => {
+ applies++;
+ },
+ isCurrent: () => current
+ });
+
+ await started;
+ current = false;
+ const second = submitter.submit({
+ validate: async () => ({ status: 'ok' }),
+ commit: async () => {
+ commits++;
+ },
+ isCurrent: () => true
+ });
+
+ assert.equal(second, null);
+ assert.equal(submitter.isBusy(), true);
+ finishSave();
+ const result = await first;
+
+ assert.equal(result.status, 'stale');
+ assert.equal(result.committed, true);
+ assert.equal(commits, 1);
+ assert.equal(applies, 1);
+ assert.equal(submitter.isBusy(), false);
+});
+
+test('post-save apply failure remains committed and cannot invite a duplicate retry', async () => {
+ const expected = new Error('render failed');
+ let saves = 0;
+ let applies = 0;
+ const result = await submitValidatedAccount({
+ validate: async () => ({ status: 'ok' }),
+ commit: async () => {
+ saves++;
+ return { accountId: 'saved-account' };
+ },
+ afterCommit: async () => {
+ applies++;
+ throw expected;
+ },
+ isCurrent: () => true
+ });
+
+ assert.equal(result.status, 'committed');
+ assert.equal(result.value.accountId, 'saved-account');
+ assert.equal(result.postCommitError, expected);
+ assert.equal(saves, 1);
+ assert.equal(applies, 1);
+});
+
+test('ok validates and commits exactly once in one submission', async () => {
+ let validations = 0;
+ let commits = 0;
+ const result = await submitValidatedAccount({
+ validate: async () => {
+ validations++;
+ return { status: 'ok', message: 'Login erfolgreich' };
+ },
+ commit: async () => {
+ commits++;
+ },
+ isCurrent: () => true
+ });
+
+ assert.equal(result.status, 'committed');
+ assert.equal(validations, 1);
+ assert.equal(commits, 1);
+});
+
+test('warn validates and commits exactly once in one submission', async () => {
+ let commits = 0;
+ const validation = { status: 'warn', message: 'Login mit Warnung' };
+ const result = await submitValidatedAccount({
+ validate: async () => validation,
+ commit: async (received) => {
+ commits++;
+ assert.equal(received, validation);
+ },
+ isCurrent: () => true
+ });
+
+ assert.equal(result.status, 'committed');
+ assert.equal(result.validation, validation);
+ assert.equal(commits, 1);
+});
+
+for (const status of ['error', 'skipped']) {
+ test(`${status} rejects without committing`, async () => {
+ let commits = 0;
+ const validation = { status, message: `${status} result` };
+ const result = await submitValidatedAccount({
+ validate: async () => validation,
+ commit: async () => {
+ commits++;
+ },
+ isCurrent: () => true
+ });
+
+ assert.equal(result.status, 'rejected');
+ assert.equal(result.validation, validation);
+ assert.equal(commits, 0);
+ });
+}
+
+test('validate throw returns error without committing', async () => {
+ const expected = new Error('validation failed');
+ let commits = 0;
+ const result = await submitValidatedAccount({
+ validate: async () => {
+ throw expected;
+ },
+ commit: async () => {
+ commits++;
+ },
+ isCurrent: () => true
+ });
+
+ assert.equal(result.status, 'error');
+ assert.equal(result.error, expected);
+ assert.equal(commits, 0);
+});
+
+test('otp_required returns challenge without committing', async () => {
+ let commits = 0;
+ const validation = { status: 'otp_required', message: 'OTP gesendet' };
+ const result = await submitValidatedAccount({
+ validate: async () => validation,
+ commit: async () => {
+ commits++;
+ },
+ isCurrent: () => true
+ });
+
+ assert.equal(result.status, 'otp_required');
+ assert.equal(result.validation, validation);
+ assert.equal(commits, 0);
+});
+
+test('stale submission is rejected immediately before commit', async () => {
+ let current = true;
+ let commits = 0;
+ const validation = { status: 'ok' };
+ const result = await submitValidatedAccount({
+ validate: async () => {
+ current = false;
+ return validation;
+ },
+ commit: async () => {
+ commits++;
+ },
+ isCurrent: () => current
+ });
+
+ assert.equal(result.status, 'stale');
+ assert.equal(result.validation, validation);
+ assert.equal(commits, 0);
+});
+
+test('save failure returns error after one commit attempt', async () => {
+ const expected = new Error('save failed');
+ let commits = 0;
+ const result = await submitValidatedAccount({
+ validate: async () => ({ status: 'ok' }),
+ commit: async () => {
+ commits++;
+ throw expected;
+ },
+ isCurrent: () => true
+ });
+
+ assert.equal(result.status, 'error');
+ assert.equal(result.error, expected);
+ assert.equal(commits, 1);
+});
diff --git a/tests/webhook-notify.test.js b/tests/webhook-notify.test.js
new file mode 100644
index 0000000..3ae4ccb
--- /dev/null
+++ b/tests/webhook-notify.test.js
@@ -0,0 +1,156 @@
+const test = require('node:test');
+const assert = require('node:assert');
+const { isDiscordWebhook, formatDurationShort, summarizePerHosterFromBatch, buildWebhookRequest, resolveDiscordMention, isAllAborted, clampDiscordContent, DISCORD_CONTENT_LIMIT } = require('../lib/webhook-notify');
+
+const SAMPLE_SUMMARY = {
+ total: 10,
+ succeeded: 8,
+ failed: 2,
+ files: [
+ { name: 'a.mkv', results: [
+ { hoster: 'voe.sx', status: 'done' },
+ { hoster: 'byse.sx', status: 'error', error: 'x' }
+ ] },
+ { name: 'b.mkv', results: [
+ { hoster: 'voe.sx', status: 'done' },
+ { hoster: 'byse.sx', status: 'done' }
+ ] }
+ ]
+};
+
+test('isDiscordWebhook recognizes discord URLs incl. ptb/canary/discordapp', () => {
+ assert.ok(isDiscordWebhook('https://discord.com/api/webhooks/123/abc'));
+ assert.ok(isDiscordWebhook('https://discordapp.com/api/webhooks/123/abc'));
+ assert.ok(isDiscordWebhook('https://ptb.discord.com/api/webhooks/123/abc'));
+ assert.ok(isDiscordWebhook('https://canary.discord.com/api/webhooks/123/abc'));
+ assert.strictEqual(isDiscordWebhook('https://example.com/hook'), false);
+ assert.strictEqual(isDiscordWebhook(''), false);
+ assert.strictEqual(isDiscordWebhook(null), false);
+});
+
+test('isDiscordWebhook REJECTS incomplete discord URLs (no id/token)', () => {
+ assert.strictEqual(isDiscordWebhook('https://discord.com/api/webhooks/'), false);
+ assert.strictEqual(isDiscordWebhook('https://discord.com/api/webhooks'), false);
+ assert.strictEqual(isDiscordWebhook('https://discord.com/api/webhooks/123'), false);
+ assert.strictEqual(isDiscordWebhook('https://discord.com/api/webhooks/123/'), false);
+ assert.ok(isDiscordWebhook('https://discord.com/api/webhooks/123456789/aBc-_token123'));
+});
+
+test('clampDiscordContent caps to the Discord limit with ellipsis', () => {
+ const short = 'hello';
+ assert.strictEqual(clampDiscordContent(short), short);
+ const long = 'x'.repeat(5000);
+ const clamped = clampDiscordContent(long);
+ assert.ok(clamped.length <= DISCORD_CONTENT_LIMIT);
+ assert.ok(clamped.endsWith('…'));
+});
+
+test('buildWebhookRequest: many hosters does not exceed Discord limit', () => {
+ const files = [{ name: 'a.mkv', results: [] }];
+ for (let i = 0; i < 60; i++) files[0].results.push({ hoster: `hoster-with-a-really-long-name-${i}.example.com`, status: 'done' });
+ const req = buildWebhookRequest('https://discord.com/api/webhooks/1/x', { total: 60, succeeded: 60, failed: 0, files }, { durationSec: 60 });
+ const body = JSON.parse(req.body);
+ assert.ok(body.content.length <= DISCORD_CONTENT_LIMIT, `content ${body.content.length} must be <= ${DISCORD_CONTENT_LIMIT}`);
+ assert.match(body.content, /\+\d+/);
+});
+
+test('buildWebhookRequest: aborted meta changes the headline', () => {
+ const req = buildWebhookRequest('https://discord.com/api/webhooks/1/x', { total: 5, succeeded: 0, failed: 5, files: [] }, { aborted: true });
+ const body = JSON.parse(req.body);
+ assert.match(body.content, /Batch abgebrochen/);
+});
+
+test('isAllAborted: true only when every result is aborted', () => {
+ assert.strictEqual(isAllAborted({ files: [{ results: [{ status: 'aborted' }, { status: 'aborted' }] }] }), true);
+ assert.strictEqual(isAllAborted({ files: [{ results: [{ status: 'aborted' }, { status: 'done' }] }] }), false);
+ assert.strictEqual(isAllAborted({ files: [{ results: [{ status: 'error' }] }] }), false);
+ assert.strictEqual(isAllAborted({ files: [] }), false);
+ assert.strictEqual(isAllAborted(null), false);
+});
+
+test('formatDurationShort formats h/m/s tiers', () => {
+ assert.strictEqual(formatDurationShort(45), '45s');
+ assert.strictEqual(formatDurationShort(125), '2m 5s');
+ assert.strictEqual(formatDurationShort(3 * 3600 + 12 * 60), '3h 12m');
+ assert.strictEqual(formatDurationShort(-5), '0s');
+ assert.strictEqual(formatDurationShort(undefined), '0s');
+});
+
+test('summarizePerHosterFromBatch counts ok/fail per hoster', () => {
+ const s = summarizePerHosterFromBatch(SAMPLE_SUMMARY);
+ assert.deepStrictEqual(s['voe.sx'], { ok: 2, fail: 0 });
+ assert.deepStrictEqual(s['byse.sx'], { ok: 1, fail: 1 });
+});
+
+test('summarizePerHosterFromBatch handles malformed input', () => {
+ assert.deepStrictEqual(summarizePerHosterFromBatch(null), {});
+ assert.deepStrictEqual(summarizePerHosterFromBatch({}), {});
+ assert.deepStrictEqual(summarizePerHosterFromBatch({ files: [{ results: null }] }), {});
+});
+
+test('buildWebhookRequest produces Discord content body for discord URLs', () => {
+ const req = buildWebhookRequest('https://discord.com/api/webhooks/1/x', SAMPLE_SUMMARY, { durationSec: 3700, appVersion: '3.3.59', machineName: 'srv-1' });
+ assert.strictEqual(req.method, 'POST');
+ assert.strictEqual(req.headers['Content-Type'], 'application/json');
+ const body = JSON.parse(req.body);
+ assert.ok(typeof body.content === 'string');
+ assert.match(body.content, /Batch fertig/);
+ assert.match(body.content, /srv-1/);
+ assert.match(body.content, /8 ok/);
+ assert.match(body.content, /2 Fehler/);
+ assert.match(body.content, /1h 1m/);
+ assert.match(body.content, /voe\.sx: 2\/2/);
+});
+
+test('buildWebhookRequest produces raw JSON payload for generic URLs', () => {
+ const req = buildWebhookRequest('https://example.com/hook', SAMPLE_SUMMARY, { durationSec: 60, appVersion: '3.3.59', timestamp: '2026-06-09T00:00:00Z' });
+ const body = JSON.parse(req.body);
+ assert.strictEqual(body.event, 'batch-done');
+ assert.strictEqual(body.total, 10);
+ assert.strictEqual(body.succeeded, 8);
+ assert.strictEqual(body.failed, 2);
+ assert.strictEqual(body.durationSec, 60);
+ assert.strictEqual(body.version, '3.3.59');
+ assert.deepStrictEqual(body.perHoster['byse.sx'], { ok: 1, fail: 1 });
+});
+
+test('resolveDiscordMention: @here / @everyone use parse=everyone', () => {
+ assert.deepStrictEqual(resolveDiscordMention('@here'), { token: '@here', allowed: { parse: ['everyone'] } });
+ assert.deepStrictEqual(resolveDiscordMention('everyone'), { token: '@everyone', allowed: { parse: ['everyone'] } });
+});
+
+test('resolveDiscordMention: bare numeric id → user mention', () => {
+ assert.deepStrictEqual(resolveDiscordMention('123456789012345'), { token: '<@123456789012345>', allowed: { users: ['123456789012345'] } });
+ assert.deepStrictEqual(resolveDiscordMention('<@!123456789012345>'), { token: '<@123456789012345>', allowed: { users: ['123456789012345'] } });
+});
+
+test('resolveDiscordMention: role:id and <@&id> → role mention', () => {
+ assert.deepStrictEqual(resolveDiscordMention('role:99887766'), { token: '<@&99887766>', allowed: { roles: ['99887766'] } });
+ assert.deepStrictEqual(resolveDiscordMention('<@&99887766>'), { token: '<@&99887766>', allowed: { roles: ['99887766'] } });
+});
+
+test('resolveDiscordMention: empty / junk → null', () => {
+ assert.strictEqual(resolveDiscordMention(''), null);
+ assert.strictEqual(resolveDiscordMention(' '), null);
+ assert.strictEqual(resolveDiscordMention('not-an-id'), null);
+});
+
+test('buildWebhookRequest: discord with mention prepends token + sets allowed_mentions', () => {
+ const req = buildWebhookRequest('https://discord.com/api/webhooks/1/x', SAMPLE_SUMMARY, { durationSec: 60, mention: '123456789012345' });
+ const body = JSON.parse(req.body);
+ assert.ok(body.content.startsWith('<@123456789012345> '));
+ assert.deepStrictEqual(body.allowed_mentions, { users: ['123456789012345'] });
+});
+
+test('buildWebhookRequest: discord without mention blocks all pings (allowed_mentions parse empty)', () => {
+ const req = buildWebhookRequest('https://discord.com/api/webhooks/1/x', SAMPLE_SUMMARY, { durationSec: 60 });
+ const body = JSON.parse(req.body);
+ assert.deepStrictEqual(body.allowed_mentions, { parse: [] });
+});
+
+test('buildWebhookRequest tolerates empty summary', () => {
+ const req = buildWebhookRequest('https://example.com/hook', null, {});
+ const body = JSON.parse(req.body);
+ assert.strictEqual(body.total, 0);
+ assert.strictEqual(body.succeeded, 0);
+});