'; }
+ 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).
+ const _thisManager = uploadManager;
+ 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}`);
+ }
+ safeSend('upload-batch-done', summary);
+
+ 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) { debugLog('nextTick: uploadManager was nulled before startBatch'); return; }
+ debugLog(`nextTick: calling startBatch now (priming ${_sessionFailedAccounts.size} failed accounts, ${_sessionAccountOverrides.size} overrides from session)`);
+ uploadManager.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);
+ 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 (!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 () => {
+ await configStore.clearHistory();
+ return true;
+});
+
+// --- 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 };
+ const config = configStore.load();
+ config.history = [];
+ 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 = fs.readFileSync(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 = fs.readFileSync(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;
+ // Validate imported data has required structure
+ if (!imported || typeof imported !== 'object' || !imported.hosters || !imported.hosterSettings || !imported.globalSettings) {
+ return { ok: false, error: 'Backup-Datei hat ungültige Struktur (hosters, hosterSettings oder globalSettings fehlt).' };
+ }
+ // Safety net: timestamped backup so multiple imports don't overwrite each other
+ const ts = new Date().toISOString().replace(/[:.]/g, '-');
+ const preImportPath = configStore.filePath.replace('.json', `.pre-import-${ts}.json`);
+ try { fs.copyFileSync(configStore.filePath, preImportPath); } catch {}
+ // Strip machine-specific state because imported absolute paths can point to
+ // locations that do not exist on the current system.
+ // Any path that does not resolve locally is cleared so the user can re-set it
+ // instead of hitting silent failures later.
+ const importedGlobal = imported.globalSettings || {};
+ if (importedGlobal.logFilePath && !fs.existsSync(path.dirname(importedGlobal.logFilePath))) {
+ importedGlobal.logFilePath = '';
+ }
+ if (importedGlobal.folderMonitor && typeof importedGlobal.folderMonitor === 'object') {
+ const fm = importedGlobal.folderMonitor;
+ if (fm.folderPath && !fs.existsSync(fm.folderPath)) {
+ fm.folderPath = '';
+ fm.enabled = false;
+ }
+ }
+ importedGlobal.pendingQueue = null;
+ // Single atomic write — no split state, no TOCTOU race
+ const merged = {
+ hosters: imported.hosters,
+ hosterSettings: imported.hosterSettings,
+ globalSettings: importedGlobal,
+ history: []
+ };
+ await configStore._atomicWrite(configStore._serializeForDisk(merged));
+ _invalidateLogSettings();
+ return { ok: true, config: configStore.load() };
+});
+
+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', () => {
+ try { if (uploadManager) uploadManager.cancel(); } catch {}
+ installUpdate((progress) => {
+ safeSend('app:update-progress', progress);
+ }).catch((err) => {
+ safeSend('app:update-progress', { stage: 'error', error: err.message });
+ });
+ return { started: true };
+});
+
+ipcMain.handle('app:abort-update', () => {
+ abortUpdate();
+ return true;
+});
+
+ipcMain.handle('app:get-version', () => {
+ return app.getVersion();
+});
+
+ipcMain.handle('app:restart', () => {
+ app.relaunch();
+ app.quit();
+});
+
+ipcMain.handle('app:quit', () => {
+ app.quit();
+});
+
+// --- Hoster settings ---
+ipcMain.handle('get-hoster-settings', () => {
+ const config = configStore.load();
+ return config.hosterSettings || {};
+});
+
+ipcMain.handle('save-hoster-settings', async (_event, hosterSettings) => {
+ await configStore.save({ hosterSettings });
+ if (uploadManager) uploadManager.updateSettings(hosterSettings, null);
+ return true;
+});
+
+// --- Global settings ---
+ipcMain.handle('get-global-settings', () => {
+ const config = configStore.load();
+ return config.globalSettings || {};
+});
+
+function _preserveDiagSubtree(globalSettings) {
+ if (!globalSettings || typeof globalSettings !== 'object') return globalSettings;
+ try {
+ const cur = configStore.load();
+ if (cur.globalSettings && cur.globalSettings.diagnostics) {
+ globalSettings.diagnostics = cur.globalSettings.diagnostics;
+ }
+ } catch {}
+ return globalSettings;
+}
+
+ipcMain.handle('save-global-settings', async (_event, globalSettings) => {
+ globalSettings = _preserveDiagSubtree(globalSettings);
+ await configStore.save({ globalSettings });
+ _invalidateLogSettings();
+ if (uploadManager) uploadManager.updateSettings(null, globalSettings);
+ 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 {}
+}
+
+// Synchronous save for beforeunload — blocks renderer until write completes
+// Uses atomic write pattern (tmp + backup + rename) to prevent corruption.
+// Returns false on any failure so the renderer (which surfaces this via the
+// beforeunload chain) doesn't quietly think queue + settings persisted when
+// they didn't. Errors are logged for diagnostics regardless.
+ipcMain.on('save-global-settings-sync', (event, globalSettings) => {
+ const tmpPath = configStore.filePath + '.' + process.pid + '.tmp';
+ try {
+ const current = configStore.load();
+ const _diskDiag = current.globalSettings && current.globalSettings.diagnostics;
+ current.globalSettings = globalSettings;
+ if (_diskDiag) current.globalSettings.diagnostics = _diskDiag;
+ try { configStore._guardHosters(current, false); } catch {}
+ _invalidateLogSettings();
+ const data = configStore._serializeForDisk(current);
+ const backupPath = configStore.filePath + '.bak';
+ const _fd = fs.openSync(tmpPath, 'w');
+ try { fs.writeSync(_fd, data); fs.fsyncSync(_fd); } finally { fs.closeSync(_fd); }
+ if (fs.existsSync(configStore.filePath)) {
+ // Use try/catch around the read so an AV/lock race doesn't fail the
+ // whole save just because we couldn't refresh the .bak — the write to
+ // the live file via rename is what matters.
+ try {
+ const existing = fs.readFileSync(configStore.filePath, 'utf-8');
+ if (existing && existing.trim().length > 2) {
+ fs.writeFileSync(backupPath, existing, 'utf-8');
+ }
+ } catch (bakErr) {
+ debugLog(`save-global-settings-sync: backup read/write skipped: ${bakErr.message}`);
+ }
+ }
+ let renamed = false;
+ let lastErr = null;
+ for (let attempt = 0; attempt < 5 && !renamed; attempt++) {
+ try {
+ fs.renameSync(tmpPath, configStore.filePath);
+ renamed = true;
+ } catch (renameErr) {
+ lastErr = renameErr;
+ const code = renameErr && renameErr.code;
+ if (code === 'EBUSY' || code === 'EPERM' || code === 'EACCES') {
+ _sleepSyncMs(40);
+ } else {
+ throw renameErr;
+ }
+ }
+ }
+ if (!renamed) throw lastErr || new Error('renameSync failed');
+ event.returnValue = true;
+ } catch (err) {
+ try { if (fs.existsSync(tmpPath)) fs.unlinkSync(tmpPath); } catch {}
+ debugLog(`save-global-settings-sync FAILED: ${err && err.message ? err.message : err}`);
+ event.returnValue = false;
+ }
+});
+
+// --- 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) => {
+ 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 () => {
+ 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) {
+ token = generateToken();
+ const gs = { ...config.globalSettings, remote: { ...remote, token } };
+ await configStore.save({ globalSettings: gs });
+ }
+
+ remoteServer = new RemoteServer();
+ 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()
+ });
+
+ 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) => {
+ const config = configStore.load();
+ const gs = { ...config.globalSettings, remote: remoteSettings };
+ await configStore.save({ globalSettings: gs });
+
+ if (remoteSettings.enabled) {
+ await startRemoteServer();
+ } else if (remoteServer) {
+ remoteServer.stop();
+ remoteServer = null;
+ destroyCaptureWindow();
+ debugLog('remote-server stopped');
+ }
+ return true;
+});
+
+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) => {
+ 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..e3cb9e6
--- /dev/null
+++ b/package-lock.json
@@ -0,0 +1,4948 @@
+{
+ "name": "multi-hoster-uploader",
+ "version": "3.3.108",
+ "lockfileVersion": 3,
+ "requires": true,
+ "packages": {
+ "": {
+ "name": "multi-hoster-uploader",
+ "version": "3.3.108",
+ "dependencies": {
+ "chokidar": "^3.6.0",
+ "undici": "^7.28.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.28.0",
+ "resolved": "https://registry.npmjs.org/undici/-/undici-7.28.0.tgz",
+ "integrity": "sha512-cRZYrTDwWznlnRiPjggAGxZXanty6M8RV1ff8Wm4LWXBp7/IG8v5DnOm74DtUBp9OONpK75YlPnIjQqX0dBDtA==",
+ "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..7699904
--- /dev/null
+++ b/package.json
@@ -0,0 +1,57 @@
+{
+ "name": "multi-hoster-uploader",
+ "version": "3.3.108",
+ "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",
+ "lint": "eslint .",
+ "dist": "electron-builder --win",
+ "release:win": "electron-builder --publish never --win nsis portable"
+ },
+ "dependencies": {
+ "chokidar": "^3.6.0",
+ "undici": "^7.28.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..9c0f0d4
--- /dev/null
+++ b/preload.js
@@ -0,0 +1,162 @@
+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),
+ saveGlobalSettingsSync: (settings) => ipcRenderer.sendSync('save-global-settings-sync', settings),
+
+ // 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),
+
+ // 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('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/app.js b/renderer/app.js
new file mode 100644
index 0000000..44d8a69
--- /dev/null
+++ b/renderer/app.js
@@ -0,0 +1,5640 @@
+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 _restoredSnapshotSavedAt = null;
+let settingsSaveTimer = null;
+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' };
+
+// History state
+let historyRowsData = [];
+let historySortState = { key: 'date', direction: 'desc' };
+let _historySortClicked = false;
+
+// 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');
+ const prevView = viewsById[`${activeTab.dataset.view}-view`];
+ if (prevView) prevView.classList.remove('active');
+ }
+ tab.classList.add('active');
+ 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));
+ } 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 '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': {
+ showCopyToast('Suche nach Updates…');
+ try {
+ const result = await window.api.checkForUpdate();
+ if (result && result.available) { showUpdateBanner(result); showCopyToast('Update gefunden!'); }
+ else showCopyToast('Kein Update verfügbar');
+ } catch { showCopyToast('Fehler beim Prüfen'); }
+ break;
+ }
+ }
+}
+
+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;
+ window.api.saveGlobalSettings(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;
+ window.api.saveGlobalSettings(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 globalSettings = {
+ ...(config.globalSettings || {}),
+ pendingQueue: buildPersistedQueueState()
+ };
+ config.globalSettings = globalSettings;
+ await window.api.saveGlobalSettings(globalSettings);
+}
+
+function persistQueueStateSoon(immediate) {
+ if (immediate) {
+ queuePersistThrottle.cancel();
+ persistQueueStateNow().catch(() => {});
+ return;
+ }
+ const maxWait = uploading ? 20000 : undefined;
+ queuePersistThrottle.request(() => {
+ persistQueueStateNow().catch(() => {});
+ }, 500, maxWait);
+}
+
+function clearPersistedQueueStateSoon() {
+ queuePersistThrottle.request(() => {
+ const globalSettings = {
+ ...(config.globalSettings || {}),
+ pendingQueue: null
+ };
+ config.globalSettings = globalSettings;
+ window.api.saveGlobalSettings(globalSettings).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();
+
+ 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 renderQueueTable() {
+ const tbody = document.getElementById('queueBody');
+ if (!tbody) return;
+
+ _sortedJobsCache = sortQueueJobs(queueJobs);
+ 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 {
+ const result = await window.api.exportBackup();
+ if (result && result.ok) showCopyToast('Backup exportiert');
+ } catch (err) {
+ alert('Export fehlgeschlagen: ' + (err.message || err));
+ }
+}
+
+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 {
+ const result = await window.api.importBackup(pw);
+ if (!result || result.canceled) return;
+ if (result.needsPassword) {
+ const entered = await askLegacyBackupPassword(result.hint);
+ if (entered) doBackupImport(entered);
+ return;
+ }
+ if (result.ok) {
+ config = result.config;
+ hosterSettings = config.hosterSettings || {};
+ alwaysOnTopState = !!(config.globalSettings && config.globalSettings.alwaysOnTop);
+ window.api.setAlwaysOnTop(alwaysOnTopState);
+ renderSettings();
+ renderAccounts();
+ renderHosterSummary();
+ renderHosterModal();
+ loadHistory();
+ showCopyToast('Backup importiert');
+ } 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 (e.key === 'Escape') {
+ hideContextMenu();
+ cancelHosterModal();
+ }
+ 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 if (queueJobs.length > 0) {
+ queueJobs.forEach(j => selectedJobIds.add(j.id));
+ renderQueueTable();
+ }
+ }
+ }
+ // Delete
+ if (e.key === 'Delete') {
+ if (activeView && activeView.id === 'upload-view') {
+ e.preventDefault();
+ 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) {
+ 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 window.api.setAlwaysOnTop(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 queueJobs
+ .filter(j => selectedJobIds.has(j.id) && 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() {
+ if (uploading) {
+ _hydrateMissingJobSizes();
+ const addable = queueJobs.filter(j => selectedJobIds.has(j.id) && 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();
+ 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 = queueJobs.filter((job) => selectedJobIds.has(job.id) && 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 subtabBar = document.createElement('div');
+ subtabBar.className = 'settings-subtabs';
+ subtabBar.innerHTML = `
+
+
+
+
+
+
+ `;
+ container.appendChild(subtabBar);
+
+ const pages = {};
+ ['allgemein', 'automatik', 'logs', 'remote', 'diagnose', 'backup'].forEach((id) => {
+ const page = document.createElement('div');
+ page.className = id === 'allgemein' ? 'settings-subpage active' : 'settings-subpage';
+ page.dataset.subpage = id;
+ pages[id] = page;
+ container.appendChild(page);
+ });
+
+ pages.allgemein.innerHTML = `
+ Uploads
+
+
+
+ 0 = nur pro Hoster
+
+
+
+
+ 0 = unbegrenzt
+
+ Verhalten
+
+ Updates
+
+
+
+
+ Die Upload-Einstellungen pro Hoster (Retries, Speed, Parallel, Max-Größe, Log) sind jetzt im Accounts-Tab — direkt bei den jeweiligen Hostern unter „Upload-Einstellungen".
+ `;
+
+ pages.automatik.innerHTML = `
+ Unbeaufsichtigter Betrieb
+
+
+
+ 0 = aus. Nach Batch-Ende werden transiente Fehler (Netzwerk, Hoster-Flake) automatisch bis zu N Runden neu versucht.
+
+
+
+
+ Basis-Wartezeit; Runde N wartet N × diesen Wert (lineares Backoff).
+
+
+
+
+
+ Bei Batch-Ende wird eine Zusammenfassung gepostet (Discord wird automatisch erkannt, sonst generisches JSON).
+
+
+
+
+ Damit Discord dich wirklich benachrichtigt (Push). User-ID: in Discord Entwicklermodus an → Rechtsklick auf deinen Namen → 'User-ID kopieren'. Leer = nur posten, kein Ping.
+
+ 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.logs.innerHTML = `
+ 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 = `
+ Server ${remoteSettings.enabled ? 'Aktiv' : 'Inaktiv'}
+
+
+
+
+
+
+
+
+
+
+
+ Status
+
+ Prüfe...
+
+ `;
+
+ pages.diagnose.innerHTML = `
+ Diagnose-Zugriff (nur lesen) …
+
+ Erlaubt eine externe, nur lesende Ferndiagnose von Logs, Queue-Status und sanitierter Config (Passwörter/API-Keys/Token werden maskiert). Kein Bildschirm, keine Eingabe-Steuerung. Der Verbindungs-Code ist ein Zugangsschlüssel — nur mit vertrauenswürdigen Stellen teilen; bei Verdacht „Neu" klicken. Standard-Bindung ist 127.0.0.1 (nur über SSH-/VPN-Tunnel erreichbar).
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Status
+
+ Prüfe…
+
+ `;
+
+ pages.backup.innerHTML = `
+ Alle Accounts und Einstellungen exportieren oder importieren. Der Upload-Verlauf bleibt lokal und wird nicht übertragen; nach einem Import ist der Verlauf-Tab leer.
+
+
+
+
+ `;
+
+ subtabBar.addEventListener('click', (e) => {
+ const btn = e.target.closest('[data-subtab]');
+ if (!btn) return;
+ const target = btn.dataset.subtab;
+ subtabBar.querySelectorAll('.settings-subtab').forEach((b) => {
+ b.classList.toggle('active', b === btn);
+ });
+ Object.values(pages).forEach((p) => {
+ p.classList.toggle('active', p.dataset.subpage === target);
+ });
+ });
+
+ _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;
+ }
+ await window.api.diagnosticsSaveSettings({
+ enabled: enabledEl.checked,
+ port: parseInt(portEl.value, 10) || 9110,
+ bindMode: modeEl.value,
+ publicHost: publicHostEl.value.trim(),
+ allowlist
+ });
+ 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 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('chooseLogFilePathBtn')?.addEventListener('click', chooseLogFilePath);
+ document.getElementById('openLogFolderBtn')?.addEventListener('click', () => window.api.openLogFolder());
+ document.getElementById('manualUpdateCheckBtn')?.addEventListener('click', async (e) => {
+ const btn = e.target;
+ btn.disabled = true;
+ btn.textContent = 'Prüfe...';
+ try {
+ const result = await window.api.checkForUpdate();
+ if (result && result.available) {
+ showUpdateBanner(result);
+ btn.textContent = 'Update gefunden!';
+ } else {
+ btn.textContent = 'Kein Update verfügbar';
+ }
+ } catch {
+ btn.textContent = 'Fehler beim Prüfen';
+ }
+ setTimeout(() => { btn.disabled = false; btn.textContent = 'Nach Updates suchen'; }, 3000);
+ });
+ 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() {
+ const feedback = document.getElementById('saveFeedback');
+ if (feedback) feedback.textContent = 'Speichert...';
+ clearTimeout(settingsSaveTimer);
+ settingsSaveTimer = setTimeout(() => {
+ saveSettings({ feedbackText: 'Automatisch gespeichert' }).catch((err) => {
+ if (feedback) feedback.textContent = `Speichern fehlgeschlagen: ${err.message}`;
+ });
+ }, 350);
+}
+
+async function saveSettings(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 window.api.setAlwaysOnTop(alwaysOnTopState);
+ }
+ }
+
+ // 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;
+ }
+
+ // Fire both saves in parallel instead of serializing the two IPC round-trips.
+ // Skip the getConfig refetch — we just wrote it, we know the new state, and
+ // the round-trip added 100–200ms of UI stall per keystroke (autosave fires
+ // on every input change).
+ await Promise.all([
+ window.api.saveHosterSettings(newHosterSettings),
+ window.api.saveGlobalSettings(globalSettings)
+ ]);
+ config.hosterSettings = newHosterSettings;
+ config.globalSettings = globalSettings;
+ hosterSettings = newHosterSettings;
+ clearTimeout(settingsSaveTimer);
+
+ // 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 {
+ await window.api.remoteSaveSettings(remoteSettings);
+ 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 {}
+ }
+
+ 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';
+}
+
+const _STATUS_LABELS = { ok: 'Bereit', warn: 'Warnung', checking: 'Prüfe...', error: 'Fehler', unchecked: 'Nicht geprüft' };
+
+function _buildAccountCardHtml(name, account, idx) {
+ const isDisabled = account.enabled === false;
+ const st = accountStatuses[account.id] || { status: 'unchecked', message: '' };
+ const statusLabel = isDisabled ? 'Deaktiviert' : (_STATUS_LABELS[st.status] || 'Nicht geprüft');
+ const statusClass = isDisabled ? 'disabled' : st.status;
+ 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) `
+ : '';
+
+ return `
+
+
☰
+
+
${escapeHtml(getAccountDisplayName(name, account))} ${priorityLabel} ${sessionPausedBadge}
+
${escapeHtml(subtitleText)}${st.message && !isDisabled ? ` • ${escapeHtml(st.message)}` : ''}
+
+
+
+ ${statusLabel}
+
+
+
+
+
+
+
+
+
Keine Accounts vorhanden
+
Klicke auf "Account hinzufügen", um einen Hoster einzurichten.
+
+
+
${cardsHtml}
+ ${_buildHosterSettingsHtml(name)}
+
+
+
+
+
+
+
+
+
`;
+ }
+ // API key
+ return `
+
+
+
+
+
`;
+}
+
+function openAccountModal(editAccountId) {
+ editingAccountId = editAccountId || null;
+ // Reset the two-step state — any previously validated snapshot from a prior
+ // modal session is stale and must not allow a no-recheck commit.
+ _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.`;
+ hosterRow.style.display = 'none';
+ saveBtn.textContent = 'Prüfen';
+ 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. Erst „Prüfen" klicken; nach grünem Login wird daraus „Anlegen".';
+ hosterRow.style.display = 'flex';
+ saveBtn.textContent = 'Prüfen';
+ 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);
+ }
+
+ // Toggle visibility buttons
+ credsContainer.querySelectorAll('.toggle-vis').forEach(btn => {
+ btn.addEventListener('click', () => {
+ const input = btn.previousElementSibling;
+ input.type = input.type === 'password' ? 'text' : 'password';
+ });
+ });
+
+ // Wire field invalidation: any change to a cred field after a green check
+ // drops the validated snapshot so the next click is a re-check, not a commit
+ // of unverified creds. Re-wired here every open because credsContainer's HTML
+ // was replaced.
+ _wireCredFieldInvalidation();
+
+ modal.style.display = 'flex';
+}
+
+function closeAccountModal() {
+ document.getElementById('accountModal').style.display = 'none';
+ _hideOtpField();
+ editingAccountId = null;
+ // Cancel any pending auto-close so a stale timer can't close a future modal
+ // the user reopens within the auto-close window.
+ if (_autoCloseTimer) { clearTimeout(_autoCloseTimer); _autoCloseTimer = null; }
+ _validatedCreds = null;
+ _accountModalBusy = false;
+}
+
+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.
+ window.api.saveConfig({ 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 };
+}
+
+// --- Two-step account-modal state machine ---
+//
+// Goal: never persist invalid/unverified credentials to config.hosters. The
+// user clicks "Prüfen" → ephemeral validate-credentials IPC runs → on green
+// the button label flips to "Anlegen" / "Speichern" → the next click commits
+// to config. Editing any cred field between the two clicks drops the validated
+// snapshot so the user can't sneak unverified creds through by editing
+// post-green.
+//
+// Invariants enforced here:
+// 1. Nothing reaches config.hosters until _validatedCreds matches a green
+// result for the currently-typed creds.
+// 2. _accountModalBusy is set SYNCHRONOUSLY at the top of the click handler
+// before any await — guards against double-clicks producing duplicates.
+// 3. OTP retry stays ephemeral: each retry re-runs validate-credentials with
+// the new OTP, no config writes until green.
+// 4. Edit mode hits the same path → bad edits never overwrite known-good
+// creds on disk.
+let _accountModalBusy = false;
+let _validatedCreds = null; // { hosterName, authType, snapshot, status } when green
+let _autoCloseTimer = null;
+// Session token used to ignore stale validate-credentials responses: if the
+// user closes the modal mid-flight and reopens it, the late .then must NOT
+// stomp the new session's state. Bumped on every modal reset.
+let _accountModalSession = 0;
+
+function _resetAccountModalState() {
+ _accountModalBusy = false;
+ _validatedCreds = null;
+ _accountModalSession++;
+ if (_autoCloseTimer) { clearTimeout(_autoCloseTimer); _autoCloseTimer = null; }
+}
+
+function _credsSnapshotKey(authType, creds) {
+ // Identity key for the typed creds — used to detect post-validation edits.
+ // Label changes do NOT invalidate (label is metadata, not a credential).
+ if (authType === 'login') return `login:${creds.username || ''}:${creds.password || ''}`;
+ return `api:${creds.apiKey || ''}`;
+}
+
+function _wireCredFieldInvalidation() {
+ // Any change to a cred IDENTITY field (username/password/apiKey) clears the
+ // validated snapshot and reverts the button to "Prüfen". Label edits don't
+ // invalidate (label is metadata, not a credential). OTP edits don't either:
+ // OTP is an ephemeral auth challenge — once doodstream returned "ok" for
+ // these username+password+OTP, the resulting trust is on the creds; the user
+ // clearing or fixing the OTP field afterward shouldn't force a re-prompt.
+ 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', () => {
+ if (_validatedCreds) {
+ _validatedCreds = null;
+ const saveBtn = document.getElementById('saveAccountBtn');
+ if (saveBtn) saveBtn.textContent = 'Prüfen';
+ const statusEl = document.getElementById('accountModalStatus');
+ if (statusEl) { statusEl.textContent = ''; statusEl.className = 'account-modal-status'; }
+ }
+ });
+ 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 };
+}
+
+async function saveAccount() {
+ // SYNCHRONOUS re-entry guard — must come before any await. Without this a
+ // double-click before the first IPC returns triggers two saveAccount() calls
+ // and (in the old code) two pushes/two IPCs. _accountModalBusy is checked
+ // synchronously and set synchronously, so the second click no-ops cleanly.
+ if (_accountModalBusy) 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;
+ }
+
+ // STEP 2: commit. Only fires if a previous "Prüfen" already validated the
+ // EXACT same creds (label changes don't break this — label isn't part of the
+ // credential identity).
+ const snapshotKey = _credsSnapshotKey(ctx.authType, creds);
+ if (_validatedCreds &&
+ _validatedCreds.hosterName === ctx.hosterName &&
+ _validatedCreds.authType === ctx.authType &&
+ _validatedCreds.snapshot === snapshotKey) {
+ // Set busy INSIDE the try so a sync throw on the saveBtn deref above can't
+ // leak _accountModalBusy=true and lock the user out for the session.
+ try {
+ _accountModalBusy = true;
+ saveBtn.disabled = true;
+ saveBtn.textContent = ctx.isEdit ? 'Speichere…' : 'Lege an…';
+ await _commitAccount(ctx, creds, _validatedCreds.status, _validatedCreds.message);
+ } finally {
+ _accountModalBusy = false;
+ if (saveBtn) saveBtn.disabled = false;
+ }
+ return;
+ }
+
+ // STEP 1: validate ephemerally. NOTHING is written to config.hosters here.
+ // Snapshot the session token so a stale late-arriving response from a
+ // closed-and-reopened modal can't stomp the new session's state.
+ const mySession = _accountModalSession;
+ _accountModalBusy = true;
+ saveBtn.disabled = true;
+ statusEl.textContent = 'Prüfe Login…';
+ statusEl.className = 'account-modal-status checking';
+
+ 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
+ };
+
+ let row;
+ try {
+ row = await window.api.validateCredentials(payload);
+ } catch (err) {
+ row = { status: 'error', message: err && err.message ? err.message : 'Prüfung fehlgeschlagen' };
+ } finally {
+ if (mySession === _accountModalSession) {
+ _accountModalBusy = false;
+ if (saveBtn) saveBtn.disabled = false;
+ }
+ }
+
+ // Stale response — modal was closed/reopened while we awaited. Drop it.
+ if (mySession !== _accountModalSession) return;
+
+ if (row && row.status === 'otp_required') {
+ statusEl.textContent = row.message || 'OTP wurde an deine E-Mail gesendet.';
+ statusEl.className = 'account-modal-status error';
+ _showOtpField();
+ _wireCredFieldInvalidation(); // OTP input now exists — wire its listener too
+ saveBtn.textContent = 'Mit OTP prüfen';
+ return;
+ }
+ if (row && (row.status === 'ok' || row.status === 'warn')) {
+ statusEl.textContent = row.status === 'warn' ? row.message || 'Prüfung mit Warnung abgeschlossen.' : 'Login erfolgreich! Klick „' + (ctx.isEdit ? 'Speichern' : 'Anlegen') + '" zum Übernehmen.';
+ statusEl.className = 'account-modal-status ok';
+ _hideOtpField();
+ _validatedCreds = {
+ hosterName: ctx.hosterName,
+ authType: ctx.authType,
+ snapshot: snapshotKey,
+ status: row.status,
+ message: row.message || ''
+ };
+ saveBtn.textContent = ctx.isEdit ? 'Speichern' : 'Anlegen';
+ return;
+ }
+ // error
+ const msg = (row && row.message) || 'Login fehlgeschlagen';
+ statusEl.textContent = msg;
+ statusEl.className = 'account-modal-status error';
+}
+
+async function _commitAccount(ctx, creds, validatedStatus, validatedMessage) {
+ // Persist the validated creds to config.hosters and close the modal. By the
+ // time we reach this function the validate-credentials IPC has already
+ // returned ok/warn for these exact creds, so we skip a redundant re-check.
+ let accountId;
+ if (!Array.isArray(config.hosters[ctx.hosterName])) config.hosters[ctx.hosterName] = [];
+ if (ctx.isEdit) {
+ accountId = ctx.accountId;
+ const idx = config.hosters[ctx.hosterName].findIndex(a => a.id === accountId);
+ if (idx >= 0) {
+ config.hosters[ctx.hosterName][idx] = { ...config.hosters[ctx.hosterName][idx], ...creds };
+ } else {
+ _accountModalBusy = false;
+ const _sb = document.getElementById('saveAccountBtn'); if (_sb) _sb.disabled = false;
+ const _st = document.getElementById('accountModalStatus');
+ if (_st) {
+ _st.textContent = 'Account nicht mehr in der Config — wurde extern gelöscht. Modal schließen und neu anlegen.';
+ _st.className = 'account-modal-status error';
+ }
+ return;
+ }
+ } else {
+ accountId = `${ctx.hosterName}-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+ config.hosters[ctx.hosterName].push({ id: accountId, ...creds });
+ }
+ await window.api.saveConfig({ hosters: config.hosters });
+ // Skip the redundant await getConfig() — the in-memory state is the source
+ // of truth for what we just wrote, decrypted creds didn't change, and the
+ // round-trip was the main lag source on add/delete.
+ accountStatuses[accountId] = { status: validatedStatus, message: validatedMessage || '' };
+ ensureAccountStatusEntries();
+ syncSelectedUploadHosters();
+ // Targeted updates instead of the 4-panel cascade. For add we need a full
+ // accounts-list re-render (new card) and the hoster summary count; for edit
+ // we can update the single card. Settings panel only needs re-render if its
+ // hoster-summary section is visible — that's covered by renderHosterSummary.
+ if (ctx.isEdit) {
+ updateAccountCard(accountId);
+ } else {
+ renderAccounts();
+ }
+ renderHosterSummary();
+ // Auto-close after a short pause so the user sees the success state.
+ if (_autoCloseTimer) clearTimeout(_autoCloseTimer);
+ _autoCloseTimer = setTimeout(() => { closeAccountModal(); _autoCloseTimer = null; }, 600);
+}
+
+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 = [];
+ container.innerHTML = 'Noch keine Uploads.
';
+ return;
+ }
+
+ historySortState = { key: 'date', direction: 'desc' };
+ historyRowsData = [];
+ 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 || [])) {
+ if (result.status === 'aborted' || result.status === 'error') continue;
+ historyRowsData.push({
+ date: dt.text, dateTs: dt.ts,
+ filename: file.name || '', host: result.hoster || '',
+ link: result.download_url || result.embed_url || '',
+ isError: false, order: order++
+ });
+ }
+ }
+ }
+
+ 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 renderHistoryTable(container) {
+ if (!container || !historyRowsData.length) {
+ if (container) container.innerHTML = 'Noch keine Uploads.
';
+ const emptyNotice = document.getElementById('historyCapNotice');
+ if (emptyNotice) emptyNotice.style.display = 'none';
+ _historyWorking = [];
+ return;
+ }
+
+ const total = historyRowsData.length;
+ const working = total > HISTORY_RENDER_CAP ? historyRowsData.slice(-HISTORY_RENDER_CAP) : historyRowsData;
+ 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', 'Date')}${headerCell('filename', 'Filename')}${headerCell('host', 'Host')}${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;
+ });
+}
+
+// Flush pending queue state on window close (sync IPC — blocks until save completes)
+window.addEventListener('beforeunload', () => {
+ // Flush pending settings save if user changed settings right before closing
+ if (settingsSaveTimer) {
+ clearTimeout(settingsSaveTimer);
+ settingsSaveTimer = null;
+ try { saveSettings(); } catch {}
+ }
+ queuePersistThrottle.cancel();
+ // Drain pending done-removals synchronously before persisting so jobs the
+ // user expected to disappear (removeFromQueueOnDone=true) don't reappear
+ // on next launch. Microtask wouldn't run before the sync IPC below.
+ if (_doneRemovalCoalescer) _doneRemovalCoalescer.drainSync();
+ const globalSettings = {
+ ...(config.globalSettings || {}),
+ pendingQueue: buildPersistedQueueState()
+ };
+ config.globalSettings = globalSettings;
+ window.api.saveGlobalSettingsSync(globalSettings);
+});
+
+// --- Setup Listeners ---
+function setupListeners() {
+ try { initMenuBar(); } catch (err) { console.error('menu bar init failed', err); }
+ 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;
+ await window.api.clearHistory();
+ loadHistory();
+ });
+ 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; }
+ }
+ }
+ const globalSettings = { ...(config.globalSettings || {}), historyRetention: value };
+ config.globalSettings = globalSettings;
+ await window.api.saveGlobalSettings(globalSettings).catch(() => {});
+ if (value !== 'all') {
+ const res = await window.api.pruneHistory(value);
+ if (res && res.removedRows > 0) showCopyToast(`Verlauf gekürzt: ${res.removedRows.toLocaleString('de-DE')} entfernt`);
+ }
+ loadHistory();
+ });
+ }
+
+ // 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('.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) => {
+ 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);
+ credsContainer.querySelectorAll('.toggle-vis').forEach(btn => {
+ btn.addEventListener('click', () => {
+ const input = btn.previousElementSibling;
+ input.type = input.type === 'password' ? 'text' : 'password';
+ });
+ });
+ document.getElementById('accountModalStatus').textContent = '';
+ document.getElementById('accountModalStatus').className = 'account-modal-status';
+ // Hoster changed → any prior validation is stale by construction. Drop the
+ // snapshot and revert the button so the user has to re-Prüfen.
+ _validatedCreds = null;
+ const sb = document.getElementById('saveAccountBtn');
+ if (sb) sb.textContent = 'Prüfen';
+ // The cred inputs were just replaced — rewire invalidation listeners on
+ // the fresh elements so post-validation edits still revert the button.
+ _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();
+ });
+}
+
+// --- Update UI ---
+function showUpdateBanner(info) {
+ const banner = document.getElementById('updateBanner');
+ const msg = document.getElementById('updateMessage');
+ if (!banner || !msg) return;
+ msg.textContent = `Update v${info.remoteVersion} verfügbar`;
+ banner.style.display = 'flex';
+ document.getElementById('installUpdateBtn').onclick = async () => {
+ msg.textContent = 'Update wird heruntergeladen...';
+ document.getElementById('installUpdateBtn').disabled = true;
+ await persistQueueStateNow().catch(() => {}); // Save queue before update restart
+ await window.api.installUpdate();
+ };
+ document.getElementById('dismissUpdateBtn').onclick = () => { banner.style.display = 'none'; };
+}
+
+function handleUpdateProgress(data) {
+ const msg = document.getElementById('updateMessage');
+ if (!msg) return;
+ if (data.stage === 'downloading') msg.textContent = `Downloading... ${data.percent || 0}%`;
+ else if (data.stage === 'verifying') msg.textContent = 'Verifiziere...';
+ else if (data.stage === 'launching') msg.textContent = 'Setup wird gestartet...';
+ else if (data.stage === 'done') msg.textContent = 'Update installiert. App wird neu gestartet...';
+ else if (data.stage === 'error') {
+ msg.textContent = `Update fehlgeschlagen: ${data.error}`;
+ const btn = document.getElementById('installUpdateBtn');
+ if (btn) { btn.disabled = false; btn.textContent = 'Erneut versuchen'; }
+ }
+}
+
+// --- 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 ---
+init().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..5c8216e
--- /dev/null
+++ b/renderer/drop-target.html
@@ -0,0 +1,68 @@
+
+
+
+
+
+
+
+
+
+
+
diff --git a/renderer/index.html b/renderer/index.html
new file mode 100644
index 0000000..15b1a93
--- /dev/null
+++ b/renderer/index.html
@@ -0,0 +1,426 @@
+
+
+
+
+
+ Multi-Hoster-Upload
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
📁
+
Dateien hierher ziehen oder klicken
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ | Filename |
+ Uploaded / Size |
+ Host |
+ Status |
+ Zeit |
+ Rest |
+ Speed |
+ Progress |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ | Datum▼ |
+ Filename↕ |
+ Host↕ |
+ Link↕ |
+
+
+
+
+
+
+
+
+
+
Files in queue (count)
+
total:0
+
done:0
+
remaining:0
+
in progress:0
+
error:0
+
+
+
File size in queue
+
total:0 B
+
remaining:0 B
+
+
+
Session
+
Upload speed:0 B/s
+
Remaining time:--:--
+
Run time:00:00:00
+
Uploaded (this run):0 B
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Account wirklich löschen?
+
+
+
+
+
+
Upload-Einstellungen
+
Hoster-Einstellungen erscheinen erst, sobald ein Account hinterlegt ist. Änderungen werden automatisch gespeichert.
+
+
+ Änderungen werden automatisch gespeichert.
+
+
+
+
+ Bereit
+ |
+ 0 kB/s
+ |
+ 0 B
+ |
+ ETA --:--
+ |
+ Aktive Verbindungen 0
+ |
+ Gesamt 0
+ |
+ Remaining 0
+ |
+ In Progress 0
+ |
+ Done 0
+ |
+ Error 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 csrfCandidate = ['fixture', 'csrf', 'candidate', '00000001'].join('');
+ const apiCandidate = ['fixture', 'api', 'candidate', '0000000001'].join('');
+ const html = `
+
+ API Key
+ `;
+ const cands = up._extractApiKeyCandidates(html);
+ // The token whose preceding context mentions "API" must rank first.
+ assert.equal(cands[0], apiCandidate);
+ assert.ok(cands.includes(csrfCandidate));
+});
+
+test('_extractApiKeyCandidates handles textarea + api_key: "x" shapes and empty input', () => {
+ const up = new DoodstreamUploader();
+ assert.deepEqual(up._extractApiKeyCandidates(''), []);
+ const textareaCandidate = ['fixture', 'textarea', 'candidate', '000001'].join('');
+ const objectCandidate = ['fixture', 'object', 'candidate', '00000001'].join('');
+ const ta = up._extractApiKeyCandidates(``);
+ assert.ok(ta.includes(textareaCandidate));
+ const js = up._extractApiKeyCandidates(`var x = {"api_key":"${objectCandidate}"};`);
+ assert.ok(js.includes(objectCandidate));
+});
+
+test('deriveApiKey returns the candidate that validates against the API', async () => {
+ const up = new DoodstreamUploader();
+ const acceptedCandidate = ['fixture', 'accepted', 'candidate', '1234567890'].join('');
+ const rejectedCandidate = ['fixture', 'rejected', 'candidate', '0987654321'].join('');
+ up._fetch = async () => ({ text: async () => `API Key
` });
+ up._validateApiKey = async (key) => key === acceptedCandidate;
+ const key = await up.deriveApiKey();
+ assert.equal(key, acceptedCandidate);
+ assert.equal(up.apiKey, acceptedCandidate); // cached on the instance
+});
+
+test('deriveApiKey returns null when no candidate validates (→ caller uses web fallback)', async () => {
+ const up = new DoodstreamUploader();
+ const rejectedCandidate = ['fixture', 'rejected', 'candidate', '0000000000'].join('');
+ 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..1e32008
--- /dev/null
+++ b/tests/history-retention.test.js
@@ -0,0 +1,84 @@
+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 only non-aborted, non-error results', () => {
+ const h = [batch('2026-01-01', 3, { aborted: 2, error: 1 })];
+ assert.strictEqual(countHistoryRows(h), 3);
+});
+
+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/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/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/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..a33ed64
--- /dev/null
+++ b/tests/support-bundle.test.js
@@ -0,0 +1,160 @@
+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');
+
+const artificialSecret = (...fragments) => fragments.join('');
+
+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 secrets = [
+ artificialSecret('fixture_token_', 'qwerty', '12345'),
+ artificialSecret('fixture_auth_', 'value', '123456'),
+ artificialSecret('fixture_refresh_', 'value', '123456'),
+ artificialSecret('fixture_bearer_', 'value', '123456'),
+ artificialSecret('fixture_authorization_', 'value', '123456')
+ ];
+ const cases = [
+ `boom token=${secrets[0]}`,
+ `response auth_token: ${secrets[1]}`,
+ `refresh_token = ${secrets[2]}`,
+ `using Bearer ${secrets[3]}`,
+ `Authorization: Bearer ${secrets[4]}`
+ ];
+ for (const [index, line] of cases.entries()) {
+ const out = redactLogText(line, []);
+ assert.ok(out.includes(REDACTED), `expected redaction in: ${line} -> ${out}`);
+ assert.ok(!out.includes(secrets[index]), `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 password = artificialSecret('fixture', 'Proxy', 'Password');
+ const out = redactLogText(`proxy https://admin:${password}@proxy.internal:8080/path`, []);
+ assert.ok(!out.includes(password), '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 basicValue = artificialSecret('dXNlcjpw', 'YXNzd29y', 'ZDEyMw');
+ const jwtValue = artificialSecret('eyJhbGciOiJIUzI1NiJ9', '.', 'eyJzdWIiOiIxMjM0NTY3ODkwIn0', '.', 'dozjgNryP4J3jVmNHl0w5N');
+ const jwtSecret = artificialSecret('eyJhbGciOiJIUzI1NiJ9', '.', 'eyJzdWIiOiIxMjM0NTY3ODkwIn0');
+ const sessionValue = artificialSecret('fixture', 'Session', 'Value', '99887766');
+ const jsonSessionValue = artificialSecret('fixture', 'Json', 'Session', '123456');
+ const cases = [
+ { line: `Authorization: Basic ${basicValue}==`, secret: basicValue },
+ { line: `jwt ${jwtValue}`, secret: jwtSecret },
+ { line: `session=${sessionValue}`, secret: sessionValue },
+ { line: `"session":"${jsonSessionValue}"`, secret: jsonSessionValue },
+ ];
+ 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..99b1f3f
--- /dev/null
+++ b/tests/ui-smoke.js
@@ -0,0 +1,322 @@
+/**
+ * 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');
+
+// Create a temp script that the real Electron app will execute via --eval
+const testScript = `
+const { app, BrowserWindow } = require('electron');
+const path = require('path');
+const fs = require('fs');
+
+async function runAfterDelay(win, delayMs) {
+ await new Promise(r => setTimeout(r, delayMs));
+ return win;
+}
+
+// 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;
+
+ // Wait for renderer init
+ await new Promise(r => setTimeout(r, 2000));
+
+ let passed = 0;
+ let failed = 0;
+ const results = [];
+
+ function check(name, condition) {
+ if (condition) { passed++; results.push(' PASS: ' + name); }
+ else { failed++; results.push(' FAIL: ' + name); }
+ }
+
+ try {
+ console.log('\\n=== Upload View ===');
+
+ const isolationRoot = process.env.UI_SMOKE_ISOLATION_ROOT || '';
+ const isolatedRootReady = path.isAbsolute(isolationRoot) && fs.existsSync(isolationRoot);
+ const isolatedAppData = isolatedRootReady && path.isAbsolute(process.env.APPDATA || '') && fs.existsSync(process.env.APPDATA) && path.resolve(process.env.APPDATA).toLowerCase() === path.resolve(isolationRoot, 'appdata').toLowerCase();
+ const isolatedLocalAppData = isolatedRootReady && path.isAbsolute(process.env.LOCALAPPDATA || '') && fs.existsSync(process.env.LOCALAPPDATA) && path.resolve(process.env.LOCALAPPDATA).toLowerCase() === path.resolve(isolationRoot, 'localappdata').toLowerCase();
+ const isolatedUserData = isolatedRootReady && path.isAbsolute(app.getPath('userData')) && fs.existsSync(app.getPath('userData')) && path.resolve(app.getPath('userData')).toLowerCase() === path.resolve(isolationRoot, 'user-data').toLowerCase();
+ console.log('Isolation: APPDATA=' + process.env.APPDATA + ' | LOCALAPPDATA=' + process.env.LOCALAPPDATA + ' | userData=' + app.getPath('userData'));
+ check('APPDATA, LOCALAPPDATA and Electron userData use isolated directories', isolatedAppData && isolatedLocalAppData && isolatedUserData);
+ check('Forced failure propagation', process.env.UI_SMOKE_FORCE_FAILURE !== '1');
+
+ const tabCount = await wc.executeJavaScript('document.querySelectorAll(".tab-bar > .tab").length');
+ check('4 main tabs exist', tabCount === 4);
+
+ const tabLabels = await wc.executeJavaScript('Array.from(document.querySelectorAll(".tab-bar > .tab"), el => el.textContent.trim()).join("|")');
+ check('Main tabs expose current views', tabLabels === 'Upload|Accounts|Einstellungen|Verlauf');
+
+ const activeTab = await wc.executeJavaScript('document.querySelector(".tab.active")?.textContent?.trim()');
+ check('Upload tab active by default', activeTab === 'Upload');
+
+ 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 queueControlCount = await wc.executeJavaScript('document.querySelectorAll("#queueCommandBar .toolbar-btn").length');
+ check('10 queue controls exist', queueControlCount === 10);
+
+ const hosterSummary = await wc.executeJavaScript('document.getElementById("hosterSummary")?.textContent');
+ check('Hoster summary reflects empty account state', hosterSummary === 'Keine Upload-Ziele ausgewählt');
+
+ const hosterOptionCount = await wc.executeJavaScript('document.querySelectorAll("#hosterModalList .hoster-option").length');
+ check('No selectable hosters without accounts', hosterOptionCount === 0);
+
+ const hosterHint = await wc.executeJavaScript('document.getElementById("hosterModalHint")?.textContent');
+ check('Hoster selection explains missing credentials', hosterHint && hosterHint.includes('Keine Hoster mit Zugangsdaten'));
+
+ 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('Product version label present', version === 'v3.3.108');
+
+ 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 accountsEmpty = await wc.executeJavaScript('document.querySelector("#accountsList .accounts-empty p")?.textContent');
+ check('Accounts show privacy-safe empty state', accountsEmpty === 'Keine Accounts vorhanden');
+
+ await wc.executeJavaScript('document.getElementById("addAccountBtn").click()');
+ await new Promise(r => setTimeout(r, 200));
+
+ const accountModalVisible = await wc.executeJavaScript('document.getElementById("accountModal")?.style.display');
+ check('Add-account modal opens', accountModalVisible === 'flex');
+
+ const accountHosterOptions = await wc.executeJavaScript('document.querySelectorAll("#accountHosterSelect option").length');
+ check('7 current hoster/auth options exist', accountHosterOptions === 7);
+
+ const accountFieldsEmpty = await wc.executeJavaScript('["accField_label","accField_username","accField_password","accField_apiKey"].filter(id => document.getElementById(id)).every(id => document.getElementById(id).value === "")');
+ check('Account fields start empty', accountFieldsEmpty);
+
+ await wc.executeJavaScript('document.getElementById("closeAccountModalBtn").click()');
+ await new Promise(r => setTimeout(r, 100));
+
+ 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);
+
+ const settingsSubtabs = await wc.executeJavaScript('document.querySelectorAll(".settings-subtab").length');
+ check('6 settings subtabs exist', settingsSubtabs === 6);
+
+ const parallel = await wc.executeJavaScript('document.getElementById("parallelUploadCountInput")?.value');
+ check('Global parallel upload default is unlimited', parallel === '0');
+
+ const settingsPointer = await wc.executeJavaScript('document.querySelector(".settings-hoster-pointer")?.textContent');
+ check('Settings points hoster controls to Accounts', settingsPointer && settingsPointer.includes('Accounts'));
+
+ console.log('\\n=== History View ===');
+
+ await wc.executeJavaScript('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 emptyState = await wc.executeJavaScript('document.querySelector("#historyContainer .empty-state")?.textContent');
+ check('Empty state or history table shown', emptyState === 'Noch keine Uploads.' || emptyState === undefined);
+
+ 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');
+
+ } catch (err) {
+ console.error('Test error:', err.message);
+ failed++;
+ }
+
+ console.log('\\n=== Results ===');
+ results.forEach(r => console.log(r));
+ console.log('\\nTotal: ' + (passed + failed) + ' | Passed: ' + passed + ' | Failed: ' + failed);
+
+ app.exit(failed > 0 ? 1 : 0);
+}, 5000);
+`;
+
+let injectRoot;
+let injectPath;
+let isolationRoot;
+let runProvenSuccessful = false;
+let childStarted = false;
+let childStartTimeMs = 0;
+let logSnapshots;
+const appPath = path.resolve(__dirname, '..');
+const protectedLogPaths = [path.join(appPath, 'crash.log'), path.join(appPath, 'upload-debug.log')];
+
+function removeTempTree(target, prefix) {
+ if (!target) return;
+ const resolvedTarget = path.resolve(target);
+ const resolvedTemp = path.resolve(os.tmpdir());
+ const validParent = path.dirname(resolvedTarget).toLowerCase() === resolvedTemp.toLowerCase();
+ const validName = path.basename(resolvedTarget).startsWith(prefix);
+ if (!validParent || !validName) {
+ throw new Error('Refusing to remove unexpected UI smoke path: ' + resolvedTarget);
+ }
+ fs.rmSync(resolvedTarget, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
+}
+
+function captureLogSnapshot(filePath) {
+ try {
+ const stats = fs.lstatSync(filePath);
+ if (!stats.isFile()) throw new Error('UI smoke protected log is not a regular file: ' + filePath);
+ return {
+ filePath,
+ existed: true,
+ bytes: fs.readFileSync(filePath),
+ mode: stats.mode,
+ atimeMs: stats.atimeMs,
+ mtimeMs: stats.mtimeMs,
+ };
+ } catch (err) {
+ if (err.code === 'ENOENT') return { filePath, existed: false };
+ throw err;
+ }
+}
+
+function restoreLogSnapshot(snapshot) {
+ let currentStats;
+ try {
+ currentStats = fs.lstatSync(snapshot.filePath);
+ } catch (err) {
+ if (err.code !== 'ENOENT') throw err;
+ }
+
+ if (snapshot.existed) {
+ if (currentStats && !currentStats.isFile()) throw new Error('UI smoke cannot restore non-file log path: ' + snapshot.filePath);
+ fs.writeFileSync(snapshot.filePath, snapshot.bytes, currentStats ? undefined : { flag: 'wx', mode: snapshot.mode });
+ fs.chmodSync(snapshot.filePath, snapshot.mode);
+ fs.utimesSync(snapshot.filePath, snapshot.atimeMs / 1000, snapshot.mtimeMs / 1000);
+ const restoredBytes = fs.readFileSync(snapshot.filePath);
+ const restoredStats = fs.statSync(snapshot.filePath);
+ if (!restoredBytes.equals(snapshot.bytes)) throw new Error('UI smoke log byte restoration failed: ' + snapshot.filePath);
+ if ((restoredStats.mode & 0o777) !== (snapshot.mode & 0o777)) throw new Error('UI smoke log mode restoration failed: ' + snapshot.filePath);
+ if (Math.abs(restoredStats.mtimeMs - snapshot.mtimeMs) > 1) throw new Error('UI smoke log mtime restoration failed: ' + snapshot.filePath);
+ return 'restored';
+ }
+
+ if (!currentStats) return 'unchanged';
+ const writtenDuringChild = childStarted && childStartTimeMs > 0 && currentStats.mtimeMs >= childStartTimeMs - 1000;
+ if (!writtenDuringChild || !currentStats.isFile()) throw new Error('UI smoke refuses to remove unproven generated log: ' + snapshot.filePath);
+ fs.unlinkSync(snapshot.filePath);
+ return 'removed';
+}
+
+try {
+ logSnapshots = protectedLogPaths.map(captureLogSnapshot);
+ isolationRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'mhu-ui-smoke-state-'));
+ const appDataDir = path.join(isolationRoot, 'appdata');
+ const localAppDataDir = path.join(isolationRoot, 'localappdata');
+ const userDataDir = path.join(isolationRoot, 'user-data');
+ for (const directory of [appDataDir, localAppDataDir, userDataDir]) {
+ fs.mkdirSync(directory);
+ if (!path.isAbsolute(directory) || fs.readdirSync(directory).length !== 0) {
+ throw new Error('UI smoke isolation directory is not new, empty and absolute: ' + directory);
+ }
+ }
+
+ injectRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'mhu-ui-smoke-inject-'));
+ injectPath = path.join(injectRoot, 'ui-inject.js');
+ fs.writeFileSync(injectPath, testScript, 'utf-8');
+
+ if (process.env.UI_SMOKE_FORCE_SETUP_FAILURE === '1') {
+ throw new Error('Forced UI smoke setup failure');
+ }
+ const electronPath = process.env.UI_SMOKE_FORCE_SPAWN_FAILURE === '1'
+ ? path.join(isolationRoot, 'missing-electron.exe')
+ : require('electron');
+ const childEnv = {
+ ...process.env,
+ APPDATA: appDataDir,
+ LOCALAPPDATA: localAppDataDir,
+ ELECTRON_USER_DATA_DIR: userDataDir,
+ UI_SMOKE_ISOLATION_ROOT: isolationRoot,
+ };
+ childStartTimeMs = Date.now();
+ let result;
+ try {
+ result = execFileSync(
+ electronPath,
+ [`--user-data-dir=${userDataDir}`, '--require', injectPath, appPath],
+ { cwd: isolationRoot, env: childEnv, timeout: process.env.UI_SMOKE_FORCE_TIMEOUT === '1' ? 1000 : 20000, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }
+ );
+ childStarted = true;
+ } catch (err) {
+ childStarted = (Number.isInteger(err.pid) && err.pid > 0) || Number.isInteger(err.status) || Boolean(err.signal);
+ throw err;
+ }
+ console.log(result);
+ runProvenSuccessful = true;
+} catch (err) {
+ 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);
+ }
+ if (!err.stdout && !err.stderr) console.error(err.message);
+ process.exitCode = Number.isInteger(err.status) && err.status > 0 && err.status <= 255 ? err.status : 1;
+} finally {
+ if (logSnapshots) {
+ const cleanupResults = [];
+ for (const snapshot of logSnapshots) {
+ try {
+ cleanupResults.push(path.basename(snapshot.filePath) + '=' + restoreLogSnapshot(snapshot));
+ } catch (err) {
+ console.error(err.message);
+ process.exitCode = 1;
+ }
+ }
+ if (cleanupResults.length) console.log('UI smoke log cleanup: ' + cleanupResults.join(', '));
+ }
+ for (const [target, prefix] of [[injectRoot, 'mhu-ui-smoke-inject-'], [isolationRoot, 'mhu-ui-smoke-state-']]) {
+ try {
+ removeTempTree(target, prefix);
+ } catch (err) {
+ console.error(err.message);
+ process.exitCode = 1;
+ }
+ }
+}
+
+if (!runProvenSuccessful && (!process.exitCode || process.exitCode === 0)) process.exitCode = 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..d37d617
--- /dev/null
+++ b/tests/upload-manager.test.js
@@ -0,0 +1,1021 @@
+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('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..58a3c7d
--- /dev/null
+++ b/tests/validate-credentials.test.js
@@ -0,0 +1,195 @@
+// Pure unit tests for the validate-credentials shape contract — does NOT spin
+// up Electron or the real per-hoster checkers. Those need network. We verify
+// the SHAPE the ephemeral hosterConfig is built into (which the per-hoster
+// checkers consume) plus the snapshot-key/invalidation invariants that the
+// renderer relies on to enforce "validated creds only".
+//
+// The three assertions the advisor called out as the regression guard for the
+// user's "mehrfach angelegt" complaint:
+// (a) failed validation persists nothing to config.hosters
+// (b) a second "Anlegen" click with the guard set persists exactly one entry
+// (c) OTP-required path persists nothing
+// are exercised at the state-machine level by simulating the renderer's logic
+// (re-implemented here as pure functions for testability — the real ones live
+// in renderer/app.js which can't run under node:test).
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+
+// ---- Re-implementations of the renderer's pure helpers ----
+// These mirror the production code exactly so the tests serve as both a guard
+// and executable spec for what saveAccount() must do.
+
+function credsSnapshotKey(authType, creds) {
+ if (authType === 'login') return `login:${creds.username || ''}:${creds.password || ''}`;
+ return `api:${creds.apiKey || ''}`;
+}
+
+function buildEphemeralHosterConfig(payload) {
+ return {
+ username: payload.username || '',
+ password: payload.password || '',
+ apiKey: payload.apiKey || '',
+ enabled: true
+ };
+}
+
+// State-machine simulator that mirrors saveAccount() WITHOUT DOM/IPC.
+function makeStateMachine({ validateImpl, persistImpl }) {
+ let busy = false;
+ let validated = null; // { hosterName, authType, snapshot, status }
+ const log = []; // log of every persist call, for assertions
+
+ async function click(ctx, creds, otp = '') {
+ if (busy) { log.push({ type: 'click-ignored-busy' }); return; }
+ const snapshot = credsSnapshotKey(ctx.authType, creds);
+
+ // STEP 2: commit if validated matches.
+ if (validated &&
+ validated.hosterName === ctx.hosterName &&
+ validated.authType === ctx.authType &&
+ validated.snapshot === snapshot) {
+ busy = true;
+ try {
+ await persistImpl(ctx, creds);
+ log.push({ type: 'persisted', accountId: ctx.accountId || `${ctx.hosterName}-NEW` });
+ } finally { busy = false; }
+ return;
+ }
+
+ // STEP 1: ephemeral validate.
+ busy = true;
+ let row;
+ try {
+ row = await validateImpl({ hoster: ctx.hosterName, authType: ctx.authType, ...creds, otp });
+ } finally { busy = false; }
+ if (row && (row.status === 'ok' || row.status === 'warn')) {
+ validated = { hosterName: ctx.hosterName, authType: ctx.authType, snapshot, status: row.status };
+ log.push({ type: 'validated', status: row.status });
+ return;
+ }
+ if (row && row.status === 'otp_required') {
+ log.push({ type: 'otp-required' });
+ return;
+ }
+ log.push({ type: 'validation-failed', message: row && row.message });
+ }
+
+ function editField() { validated = null; log.push({ type: 'invalidated-by-edit' }); }
+ return { click, editField, log: () => log.slice(), getValidated: () => validated };
+}
+
+// ---- Tests ----
+
+test('regression (a): failed validation persists NOTHING to config.hosters', async () => {
+ const persistCalls = [];
+ const sm = makeStateMachine({
+ validateImpl: async () => ({ status: 'error', message: 'Falsches Passwort' }),
+ persistImpl: async (ctx, creds) => persistCalls.push({ ctx, creds })
+ });
+ await sm.click({ hosterName: 'doodstream.com', authType: 'login', isEdit: false }, { username: 'u', password: 'wrong' });
+ assert.equal(persistCalls.length, 0, 'no persist should happen on failed validation');
+ assert.equal(sm.getValidated(), null);
+ assert.deepEqual(sm.log().map(e => e.type), ['validation-failed']);
+});
+
+test('regression (b): second click with guard set persists exactly ONE entry — no duplication', async () => {
+ const persistCalls = [];
+ let validateCount = 0;
+ const sm = makeStateMachine({
+ validateImpl: async () => { validateCount++; return { status: 'ok' }; },
+ persistImpl: async (ctx, creds) => persistCalls.push({ ctx, creds })
+ });
+ const ctx = { hosterName: 'doodstream.com', authType: 'login', isEdit: false };
+ const creds = { username: 'u', password: 'p' };
+ // Click 1 = validate → green.
+ await sm.click(ctx, creds);
+ // Click 2 = commit (same creds, validated snapshot matches).
+ await sm.click(ctx, creds);
+ // Click 3 = guard prevents a second commit because after persistImpl the
+ // state-machine in real code closes the modal. In this simulator the
+ // validated snapshot is still set — but a real double-click WHILE persistImpl
+ // is in flight would be caught by busy. Simulate that:
+ const sm2 = makeStateMachine({
+ validateImpl: async () => ({ status: 'ok' }),
+ persistImpl: () => new Promise(r => setTimeout(() => { persistCalls.push('slow'); r(); }, 30))
+ });
+ await sm2.click(ctx, creds); // validate
+ const p1 = sm2.click(ctx, creds); // start commit
+ const p2 = sm2.click(ctx, creds); // racing click — must be ignored
+ await Promise.all([p1, p2]);
+
+ assert.equal(persistCalls.length, 2, 'one persist from the deliberate two-step flow + one from sm2; racing click ignored');
+ assert.equal(validateCount, 1, 'second click reused the validated snapshot — no re-validate');
+ // The racing click MUST have been ignored by the busy guard.
+ assert.ok(sm2.log().some(e => e.type === 'click-ignored-busy'), 'busy guard fired on racing click');
+});
+
+test('regression (c): OTP-required persists NOTHING — and a follow-up click with OTP re-validates ephemerally', async () => {
+ const persistCalls = [];
+ let calls = 0;
+ const sm = makeStateMachine({
+ validateImpl: async (payload) => {
+ calls++;
+ if (!payload.otp) return { status: 'otp_required', message: 'OTP sent' };
+ if (payload.otp === '123456') return { status: 'ok' };
+ return { status: 'error', message: 'Bad OTP' };
+ },
+ persistImpl: async (ctx, creds) => persistCalls.push({ ctx, creds })
+ });
+ const ctx = { hosterName: 'doodstream.com', authType: 'login', isEdit: false };
+ const creds = { username: 'u', password: 'p' };
+ await sm.click(ctx, creds, ''); // first click → otp_required
+ await sm.click(ctx, creds, '123456'); // retry with otp → ok
+ await sm.click(ctx, creds); // final click → commit
+ assert.equal(persistCalls.length, 1, 'exactly one persist after OTP confirmed');
+ assert.equal(calls, 2, 'validate ran twice (initial + OTP) before commit');
+ assert.deepEqual(
+ sm.log().map(e => e.type),
+ ['otp-required', 'validated', 'persisted']
+ );
+});
+
+test('field edit after green check invalidates the snapshot — next click is a re-Prüfen, not a commit', async () => {
+ const persistCalls = [];
+ let validateCount = 0;
+ const sm = makeStateMachine({
+ validateImpl: async () => { validateCount++; return { status: 'ok' }; },
+ persistImpl: async (ctx, creds) => persistCalls.push({ ctx, creds })
+ });
+ const ctx = { hosterName: 'doodstream.com', authType: 'login', isEdit: false };
+ await sm.click(ctx, { username: 'u', password: 'p' }); // validate → green
+ sm.editField(); // user edits cred field → snapshot dropped
+ await sm.click(ctx, { username: 'u', password: 'newpw' }); // creds differ → re-validate
+ await sm.click(ctx, { username: 'u', password: 'newpw' }); // now commit the NEW creds
+ assert.equal(persistCalls.length, 1, 'one persist of the new (re-validated) creds');
+ assert.equal(persistCalls[0].creds.password, 'newpw', 'persisted creds match the re-validated set');
+ assert.equal(validateCount, 2, 'second validate was forced by the edit-induced invalidation');
+});
+
+test('snapshot key is identical for same creds and DIFFERENT for any cred change (excluding label)', () => {
+ // Label changes must NOT invalidate validation — label is metadata, not a credential.
+ assert.equal(credsSnapshotKey('login', { username: 'u', password: 'p' }),
+ credsSnapshotKey('login', { username: 'u', password: 'p', label: 'XYZ' }));
+ assert.notEqual(credsSnapshotKey('login', { username: 'u', password: 'p' }),
+ credsSnapshotKey('login', { username: 'u', password: 'P' })); // password char-case
+ assert.notEqual(credsSnapshotKey('login', { username: 'u', password: 'p' }),
+ credsSnapshotKey('login', { username: 'U', password: 'p' })); // username diff
+ assert.equal(credsSnapshotKey('api', { apiKey: 'KEY' }),
+ credsSnapshotKey('api', { apiKey: 'KEY', label: 'mein key' }));
+ assert.notEqual(credsSnapshotKey('api', { apiKey: 'KEY' }),
+ credsSnapshotKey('api', { apiKey: 'KEY2' }));
+});
+
+test('ephemeral hosterConfig shape matches what per-hoster checkers expect', () => {
+ // The per-hoster checkers in main.js read .username/.password/.apiKey directly.
+ // This guards the validate-credentials IPC contract from drifting.
+ const cfg = buildEphemeralHosterConfig({ hoster: 'doodstream.com', username: 'u', password: 'p' });
+ assert.equal(cfg.username, 'u');
+ assert.equal(cfg.password, 'p');
+ assert.equal(cfg.apiKey, '');
+ assert.equal(cfg.enabled, true);
+ const cfg2 = buildEphemeralHosterConfig({ hoster: 'byse.sx', apiKey: 'K' });
+ assert.equal(cfg2.apiKey, 'K');
+ assert.equal(cfg2.username, '');
+});
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);
+});