Update from Git Manager GUI

2026-03-24 16:34:40 +01:00
parent f6598cfb19
commit c64d40fbda
5 changed files with 1810 additions and 207 deletions
--- a/renderer/renderer.js
+++ b/renderer/renderer.js
@@ -63,6 +63,31 @@ function formatRelDate(iso) {
    return new Date(iso).toLocaleDateString('de-DE');
 }

+function setPlatformSelection(platform) {
+    const platformInput = $('platform');
+    if (platformInput) {
+        platformInput.value = platform;
+    }
+
+    document.querySelectorAll('.platform-option').forEach(button => {
+        const isActive = button.dataset.platform === platform;
+        button.classList.toggle('active', isActive);
+        button.setAttribute('aria-pressed', isActive ? 'true' : 'false');
+    });
+}
+
+function initializePlatformSelection() {
+    const platformInput = $('platform');
+    const initialPlatform = platformInput?.value || 'gitea';
+    setPlatformSelection(initialPlatform);
+
+    document.querySelectorAll('.platform-option').forEach(button => {
+        button.addEventListener('click', () => {
+            setPlatformSelection(button.dataset.platform || 'gitea');
+        });
+    });
+}
+
 /* Rendert Favoriten + Zuletzt-geöffnet-Bereich in ein beliebiges Container-Element */
 // Collapse-Zustand (wird in Credentials persistiert)
 const favSectionCollapsed = { favorites: false, recent: false };
@@ -299,6 +324,85 @@ let currentState = {
    path: ''
 };

+const MAX_ACTIVITY_ITEMS = 300;
+let activityEntries = [];
+let retryQueueCount = 0;
+
+function logActivity(level, message) {
+    const entry = {
+        id: `${Date.now()}-${Math.random().toString(16).slice(2)}`,
+        level: level || 'info',
+        message: String(message || ''),
+        ts: new Date().toISOString()
+    };
+    activityEntries.unshift(entry);
+    if (activityEntries.length > MAX_ACTIVITY_ITEMS) {
+        activityEntries = activityEntries.slice(0, MAX_ACTIVITY_ITEMS);
+    }
+    renderActivityLog();
+}
+
+function formatActivityTimestamp(iso) {
+    try {
+        return new Date(iso).toLocaleTimeString('de-DE', { hour12: false });
+    } catch (_) {
+        return '--:--:--';
+    }
+}
+
+function renderActivityLog() {
+    const list = $('activityLogList');
+    if (!list) return;
+
+    const filter = ($('activityFilterLevel') && $('activityFilterLevel').value) || 'all';
+    const visible = activityEntries.filter(e => filter === 'all' || e.level === filter);
+
+    if (visible.length === 0) {
+        list.innerHTML = '<div class="activity-log-item info"><span class="activity-log-message">Noch keine Einträge.</span></div>';
+        return;
+    }
+
+    list.innerHTML = visible.map(e => {
+        const lvl = (e.level || 'info').toUpperCase();
+        return `
+            <div class="activity-log-item ${e.level}">
+                <span class="activity-log-time">${formatActivityTimestamp(e.ts)}</span>
+                <span class="activity-log-level">${lvl}</span>
+                <span class="activity-log-message">${escapeHtml(e.message)}</span>
+            </div>
+        `;
+    }).join('');
+}
+
+function updateRetryQueueBadge(count) {
+    retryQueueCount = Math.max(0, Number(count || 0));
+    const btn = $('btnRetryQueueNow');
+    if (btn) btn.textContent = `🔁 Queue (${retryQueueCount})`;
+    const info = $('activityQueueInfo');
+    if (info) info.textContent = `Retry-Queue: ${retryQueueCount}`;
+}
+
+function parseBatchRepoInput(raw) {
+    return String(raw || '')
+        .split(/\r?\n/)
+        .map(line => line.trim())
+        .filter(Boolean)
+        .filter(line => line.includes('/'));
+}
+
+function updateBatchActionFields() {
+    const action = $('batchActionType')?.value || 'refresh';
+    const cloneGroup = $('batchCloneGroup');
+    const tagGroup = $('batchTagGroup');
+    const releaseNameGroup = $('batchReleaseNameGroup');
+    const releaseBodyGroup = $('batchReleaseBodyGroup');
+
+    if (cloneGroup) cloneGroup.classList.toggle('hidden', action !== 'clone');
+    if (tagGroup) tagGroup.classList.toggle('hidden', !(action === 'create-tag' || action === 'create-release'));
+    if (releaseNameGroup) releaseNameGroup.classList.toggle('hidden', action !== 'create-release');
+    if (releaseBodyGroup) releaseBodyGroup.classList.toggle('hidden', !(action === 'create-tag' || action === 'create-release'));
+}
+
 // Clipboard für Cut & Paste
 let clipboard = {
    item: null,       // { path, name, type, owner, repo, isGitea, isLocal, nodePath }
@@ -315,6 +419,131 @@ let lastSelectedItem = null;  // { type:'gitea', item, owner, repo } | { type:'l
 // Feature-Flag für farbige Icons
 let featureColoredIcons = true;

+let settingsHealth = {
+    url: 'Unbekannt',
+    api: 'Unbekannt',
+    auth: 'Unbekannt',
+    latency: '-',
+    version: '-',
+    lastError: '-'
+};
+
+function setHealthField(id, value) {
+    const el = $(id);
+    if (!el) return;
+    el.textContent = value;
+    el.classList.remove('health-ok', 'health-warn', 'health-error');
+    const v = (value || '').toLowerCase();
+    if (v === 'ok' || v === 'erreichbar' || v === 'gueltig' || v === 'gültig') {
+        el.classList.add('health-ok');
+    } else if (v === 'fehler' || v === 'ungueltig' || v === 'ungültig') {
+        el.classList.add('health-error');
+    } else if (v === 'unbekannt' || v === 'kein token' || v === 'token vorhanden' || v === 'nicht konfiguriert') {
+        el.classList.add('health-warn');
+    }
+}
+
+function renderSettingsHealth() {
+    setHealthField('healthUrl', settingsHealth.url);
+    setHealthField('healthApi', settingsHealth.api);
+    setHealthField('healthAuth', settingsHealth.auth);
+    setHealthField('healthLatency', settingsHealth.latency);
+    setHealthField('healthVersion', settingsHealth.version);
+    setHealthField('healthLastError', settingsHealth.lastError);
+}
+
+function syncSettingsPanelHeights() {
+    const credentialsPanel = document.querySelector('#settingsModal .settings-panel--credentials');
+    const healthPanel = document.querySelector('#settingsModal .settings-panel--health');
+    if (!credentialsPanel || !healthPanel) return;
+
+    healthPanel.style.minHeight = '';
+
+    // In der einspaltigen Ansicht sollen die Karten natuerlich fliessen.
+    if (window.matchMedia('(max-width: 1120px)').matches) return;
+
+    const targetHeight = Math.ceil(credentialsPanel.getBoundingClientRect().height);
+    if (targetHeight > 0) {
+        healthPanel.style.minHeight = `${targetHeight}px`;
+    }
+}
+
+function updateSettingsHealth(patch) {
+    settingsHealth = { ...settingsHealth, ...patch };
+    renderSettingsHealth();
+    syncSettingsPanelHeights();
+}
+
+function normalizeAndValidateGiteaUrl(rawUrl) {
+    const value = (rawUrl || '').trim();
+    if (!value) return { ok: true, value: '' };
+
+    let parsed;
+    try {
+        parsed = new URL(value);
+    } catch (_) {
+        return {
+            ok: false,
+            error: 'Ungültige URL. Beispiel für IPv6: http://[2001:db8::1]:3000'
+        };
+    }
+
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+        return {
+            ok: false,
+            error: 'URL muss mit http:// oder https:// beginnen.'
+        };
+    }
+
+    return { ok: true, value: value.replace(/\/$/, '') };
+}
+
+function renderGiteaUrlHint(rawValue) {
+    const hint = $('giteaUrlHint');
+    if (!hint) return;
+
+    const result = normalizeAndValidateGiteaUrl(rawValue);
+    if (!rawValue || !rawValue.trim()) {
+        hint.className = 'settings-inline-hint';
+        hint.textContent = 'Hinweis: IPv6 mit Klammern eingeben, z.B. http://[2001:db8::1]:3000';
+        return;
+    }
+
+    if (!result.ok) {
+        hint.className = 'settings-inline-hint error';
+        hint.textContent = result.error;
+        return;
+    }
+
+    hint.className = 'settings-inline-hint success';
+    hint.textContent = `Gültige URL: ${result.value}`;
+}
+
+function mapErrorMessage(message) {
+    const raw = String(message || '').toLowerCase();
+    if (!raw) return 'Unbekannter Fehler';
+
+    if (raw.includes('401') || raw.includes('unauthorized') || raw.includes('authentifizierung')) {
+        return 'Authentifizierung fehlgeschlagen. Bitte Token prüfen.';
+    }
+    if (raw.includes('403') || raw.includes('forbidden') || raw.includes('zugriff verweigert')) {
+        return 'Zugriff verweigert. Bitte Token-Berechtigungen prüfen.';
+    }
+    if (raw.includes('404') || raw.includes('not found') || raw.includes('nicht gefunden')) {
+        return 'Server oder Ressource nicht gefunden. URL/Repo prüfen.';
+    }
+    if (raw.includes('econnrefused') || raw.includes('enotfound') || raw.includes('eai_again') || raw.includes('getaddrinfo')) {
+        return 'Server nicht erreichbar. DNS, IPv4/IPv6 und Port prüfen.';
+    }
+    if (raw.includes('timeout') || raw.includes('econnaborted') || raw.includes('zeitueberschreitung') || raw.includes('zeitüberschreitung')) {
+        return 'Zeitüberschreitung bei der Verbindung. Bitte erneut versuchen.';
+    }
+    if (raw.includes('ungueltige') || raw.includes('ungültige') || raw.includes('invalid') || raw.includes('url')) {
+        return 'Ungültige URL. Beispiel für IPv6: http://[2001:db8::1]:3000';
+    }
+    return String(message);
+}
+
 function setStatus(txt) {
    const s = $('status');
    if (s) s.innerText = txt || '';
@@ -404,9 +633,15 @@ function showToast(message, type = 'info', duration = 4000) {
 }

 // Kurzformen
-function showError(msg)   { setStatus(msg); showToast(msg, 'error'); }
-function showSuccess(msg) { setStatus(msg); showToast(msg, 'success', 3000); }
-function showWarning(msg) { setStatus(msg); showToast(msg, 'warning'); }
+function showError(msg)   {
+    const friendly = mapErrorMessage(msg);
+    updateSettingsHealth({ lastError: friendly });
+    setStatus(friendly);
+    showToast(friendly, 'error');
+    logActivity('error', friendly);
+}
+function showSuccess(msg) { setStatus(msg); showToast(msg, 'success', 3000); logActivity('info', msg); }
+function showWarning(msg) { setStatus(msg); showToast(msg, 'warning'); logActivity('warning', msg); }

 // Löschen-Bestätigung als Toast (ersetzt confirm())
 function showDeleteConfirm(message, onConfirm) {
@@ -1230,7 +1465,7 @@ async function saveCurrentFile(isAutoSave = false) {
            });
        }
        
-        if (response.ok) {
+        if (response.ok && !response.queued) {
            tab.originalContent = content;
            tab.dirty = false;
            // Push current state to history
@@ -1243,6 +1478,13 @@ async function saveCurrentFile(isAutoSave = false) {
                setStatus(`✓ Gespeichert: ${tab.name}`);
            }
            console.log('✅ File saved');
+        } else if (response.ok && response.queued) {
+            tab.originalContent = content;
+            tab.dirty = false;
+            pushToHistory(content);
+            renderTabs();
+            showWarning(response.message || 'Änderung in Retry-Queue gelegt und wird später hochgeladen.');
+            updateRetryQueueBadge(retryQueueCount + 1);
        } else {
            alert(`Fehler: ${response.error}`);
        }
@@ -1363,13 +1605,17 @@ async function loadGiteaRepos() {
    }
    
    setStatus('Loading Gitea repos...');
+    updateSettingsHealth({ lastError: '-' });
    
    try {
        const res = await window.electronAPI.listGiteaRepos();
        if (!res.ok) {
            showError('Failed to load repos: ' + (res.error || 'Unknown error'));
+            updateSettingsHealth({ api: 'Fehler', auth: 'Fehler' });
            return;
        }
+
+        updateSettingsHealth({ api: 'Erreichbar', auth: 'OK', lastError: '-' });
        
        const grid = $('explorerGrid');
        if (!grid) return;
@@ -1586,6 +1832,7 @@ async function loadGiteaRepos() {
    } catch (error) {
        console.error('Error loading repos:', error);
        showError('Error loading repositories');
+        updateSettingsHealth({ api: 'Fehler', auth: 'Unbekannt' });
    }
 }

@@ -2802,8 +3049,11 @@ function setupGlobalDropZone() {
   INITIALISIERUNG
   ------------------------- */
 window.addEventListener('DOMContentLoaded', async () => {
+    initializePlatformSelection();
+
    // Favoriten & Verlauf vorladen
    await loadFavoritesAndRecent();
+    renderSettingsHealth();
    // Prevent default drag/drop on document (except in repo view)
    document.addEventListener('dragover', e => {
        if (currentState.view !== 'gitea-repo') {
@@ -2825,6 +3075,16 @@ window.addEventListener('DOMContentLoaded', async () => {
            if ($('githubToken')) $('githubToken').value = creds.githubToken || '';
            if ($('giteaToken')) $('giteaToken').value = creds.giteaToken || '';
            if ($('giteaURL')) $('giteaURL').value = creds.giteaURL || '';
+            renderGiteaUrlHint(creds.giteaURL || '');
+
+            const checkedUrl = normalizeAndValidateGiteaUrl(creds.giteaURL || '');
+            updateSettingsHealth({
+                url: checkedUrl.ok && checkedUrl.value ? 'Gültig' : (checkedUrl.ok ? 'Leer' : 'Ungültig'),
+                api: creds.giteaURL ? 'Unbekannt' : 'Nicht konfiguriert',
+                auth: creds.giteaToken ? 'Token vorhanden' : 'Kein Token',
+                latency: '-',
+                version: '-'
+            });

            // Feature-Flags aus gespeicherten Einstellungen
            if (typeof creds.featureFavorites === 'boolean') featureFavorites = creds.featureFavorites;
@@ -2863,6 +3123,15 @@ window.addEventListener('DOMContentLoaded', async () => {
        } else {
            console.log('ℹ️ Keine Credentials gespeichert');
            setStatus('Bereit - bitte Settings konfigurieren');
+            renderGiteaUrlHint('');
+            updateSettingsHealth({
+                url: 'Nicht konfiguriert',
+                api: 'Nicht konfiguriert',
+                auth: 'Kein Token',
+                latency: '-',
+                version: '-',
+                lastError: '-'
+            });
        }
    } catch (error) {
        console.error('Error loading credentials:', error);
@@ -2906,11 +3175,249 @@ window.addEventListener('DOMContentLoaded', async () => {
    if ($('btnSettings')) {
        $('btnSettings').onclick = () => {
            $('settingsModal').classList.remove('hidden');
+            $('settingsWatermarkCard')?.classList.add('hidden');
+            renderSettingsHealth();
+            requestAnimationFrame(syncSettingsPanelHeights);
+        };
+    }
+
+    if ($('btnSettingsWatermark') && $('settingsWatermarkCard')) {
+        $('btnSettingsWatermark').onclick = (e) => {
+            e.stopPropagation();
+            $('settingsWatermarkCard').classList.toggle('hidden');
+        };
+
+        $('settingsWatermarkCard').addEventListener('click', (e) => {
+            e.stopPropagation();
+        });
+
+        document.addEventListener('click', (e) => {
+            if ($('settingsModal')?.classList.contains('hidden')) return;
+            if ($('settingsWatermarkCard')?.classList.contains('hidden')) return;
+            const target = e.target;
+            if ($('btnSettingsWatermark')?.contains(target)) return;
+            if ($('settingsWatermarkCard')?.contains(target)) return;
+            $('settingsWatermarkCard')?.classList.add('hidden');
+        });
+    }
+
+    window.addEventListener('resize', syncSettingsPanelHeights);
+
+    if ($('btnBatchActions')) {
+        $('btnBatchActions').onclick = () => {
+            $('batchActionModal')?.classList.remove('hidden');
+            updateBatchActionFields();
+        };
+    }
+
+    if ($('btnOpenActivityLog')) {
+        $('btnOpenActivityLog').onclick = () => {
+            $('activityLogModal')?.classList.remove('hidden');
+            renderActivityLog();
+        };
+    }
+
+    if ($('btnCloseActivityLog')) {
+        $('btnCloseActivityLog').onclick = () => $('activityLogModal')?.classList.add('hidden');
+    }
+
+    if ($('activityFilterLevel')) {
+        $('activityFilterLevel').addEventListener('change', renderActivityLog);
+    }
+
+    if ($('btnClearActivityLog')) {
+        $('btnClearActivityLog').onclick = () => {
+            activityEntries = [];
+            renderActivityLog();
+        };
+    }
+
+    if ($('btnCloseBatchAction')) {
+        $('btnCloseBatchAction').onclick = () => $('batchActionModal')?.classList.add('hidden');
+    }
+
+    if ($('batchActionType')) {
+        $('batchActionType').addEventListener('change', updateBatchActionFields);
+        updateBatchActionFields();
+    }
+
+    if ($('btnSelectBatchCloneTarget')) {
+        $('btnSelectBatchCloneTarget').onclick = async () => {
+            const folder = await window.electronAPI.selectFolder();
+            if (folder && $('batchCloneTarget')) {
+                $('batchCloneTarget').value = folder;
+            }
+        };
+    }
+
+    if ($('btnRunBatchAction')) {
+        $('btnRunBatchAction').onclick = async () => {
+            const action = $('batchActionType')?.value || 'refresh';
+            const repos = parseBatchRepoInput($('batchRepoList')?.value || '');
+            if (repos.length === 0) {
+                showWarning('Bitte mindestens ein Repository im Format owner/repo eintragen.');
+                return;
+            }
+
+            const options = {
+                cloneTargetDir: $('batchCloneTarget')?.value || '',
+                tag: $('batchTagName')?.value || '',
+                name: $('batchReleaseName')?.value || '',
+                body: $('batchReleaseBody')?.value || ''
+            };
+
+            if (action === 'clone' && !options.cloneTargetDir) {
+                showWarning('Bitte zuerst einen Zielordner für Clone wählen.');
+                return;
+            }
+
+            if ((action === 'create-tag' || action === 'create-release') && !String(options.tag).trim()) {
+                showWarning('Bitte einen Tag eintragen.');
+                return;
+            }
+
+            const btn = $('btnRunBatchAction');
+            const old = btn.textContent;
+            btn.disabled = true;
+            btn.textContent = 'Läuft...';
+            logActivity('info', `Batch gestartet: ${action} (${repos.length} Repos)`);
+
+            try {
+                const res = await window.electronAPI.runBatchRepoAction({ action, repos, options });
+                if (!res.ok) {
+                    showError(res.error || 'Batch-Aktion fehlgeschlagen');
+                    return;
+                }
+
+                const summary = res.summary || { total: repos.length, success: 0, failed: 0 };
+                if (summary.failed > 0) {
+                    showWarning(`Batch beendet: ${summary.success}/${summary.total} erfolgreich, ${summary.failed} fehlgeschlagen.`);
+                } else {
+                    showSuccess(`Batch erfolgreich: ${summary.success}/${summary.total}`);
+                }
+
+                (res.results || []).forEach(r => {
+                    if (r.ok) logActivity('info', `${r.repo}: ${r.message || 'OK'}`);
+                    else logActivity('error', `${r.repo}: ${r.error || 'Fehler'}`);
+                });
+            } catch (error) {
+                showError(error && error.message ? error.message : String(error));
+            } finally {
+                btn.disabled = false;
+                btn.textContent = old;
+            }
+        };
+    }
+
+    if ($('btnRetryQueueNow')) {
+        $('btnRetryQueueNow').onclick = async () => {
+            try {
+                const res = await window.electronAPI.processRetryQueueNow();
+                if (res.ok) {
+                    showSuccess(`Queue verarbeitet: ${res.succeeded || 0} erfolgreich, ${res.failed || 0} verworfen.`);
+                } else {
+                    showWarning(res.error || 'Queue konnte nicht verarbeitet werden');
+                }
+            } catch (e) {
+                showError(e && e.message ? e.message : String(e));
+            }
+        };
+    }
+
+    if ($('btnRetryQueueRefresh')) {
+        $('btnRetryQueueRefresh').onclick = async () => {
+            try {
+                const res = await window.electronAPI.processRetryQueueNow();
+                if (res.ok) {
+                    showSuccess(`Queue verarbeitet: ${res.succeeded || 0} erfolgreich, ${res.failed || 0} verworfen.`);
+                } else {
+                    showWarning(res.error || 'Queue konnte nicht verarbeitet werden');
+                }
+            } catch (e) {
+                showError(e && e.message ? e.message : String(e));
+            }
+        };
+    }
+
+    if ($('giteaURL')) {
+        $('giteaURL').addEventListener('input', (e) => {
+            const raw = e.target.value;
+            renderGiteaUrlHint(raw);
+            const checked = normalizeAndValidateGiteaUrl(raw);
+            updateSettingsHealth({
+                url: checked.ok && checked.value ? 'Gültig' : (checked.ok ? 'Leer' : 'Ungültig')
+            });
+        });
+    }
+
+    if ($('btnTestGiteaConnection')) {
+        $('btnTestGiteaConnection').onclick = async () => {
+            const token = $('giteaToken')?.value || '';
+            const rawUrl = $('giteaURL')?.value || '';
+            const checked = normalizeAndValidateGiteaUrl(rawUrl);
+            if (!checked.ok) {
+                showError(checked.error);
+                updateSettingsHealth({ url: 'Ungültig', api: 'Unbekannt', auth: token ? 'Token vorhanden' : 'Kein Token' });
+                return;
+            }
+            if (!checked.value) {
+                showWarning('Bitte zuerst eine Gitea URL eintragen.');
+                return;
+            }
+
+            setStatus('Teste Gitea-Verbindung...');
+            const btn = $('btnTestGiteaConnection');
+            const oldText = btn.textContent;
+            btn.disabled = true;
+            btn.textContent = 'Teste...';
+            try {
+                const res = await window.electronAPI.testGiteaConnection({
+                    token,
+                    url: checked.value,
+                    timeout: 8000
+                });
+
+                if (!res.ok) {
+                    showError(res.error || 'Verbindungstest fehlgeschlagen');
+                    updateSettingsHealth({
+                        url: 'Gültig',
+                        api: 'Fehler',
+                        auth: token ? 'Fehler' : 'Kein Token',
+                        latency: '-',
+                        version: '-'
+                    });
+                    return;
+                }
+
+                const result = res.result || {};
+                const checks = result.checks || {};
+                const metrics = result.metrics || {};
+                const server = result.server || {};
+
+                updateSettingsHealth({
+                    url: 'Gültig',
+                    api: checks.apiReachable ? 'Erreichbar' : 'Fehler',
+                    auth: checks.authProvided ? (checks.authOk ? 'OK' : 'Fehler') : 'Kein Token',
+                    latency: metrics.latencyMs ? `${metrics.latencyMs} ms` : '-',
+                    version: server.version || '-',
+                    lastError: '-'
+                });
+
+                if (result.ok) showSuccess('Verbindung erfolgreich getestet');
+                else showWarning('Server erreichbar, aber Auth/Teilcheck fehlgeschlagen');
+            } catch (error) {
+                console.error('test-gitea-connection error:', error);
+                showError(error && error.message ? error.message : String(error));
+            } finally {
+                btn.disabled = false;
+                btn.textContent = oldText;
+            }
        };
    }
    
    if ($('btnCloseSettings')) {
        $('btnCloseSettings').onclick = () => {
+            $('settingsWatermarkCard')?.classList.add('hidden');
            $('settingsModal').classList.add('hidden');
        };
    }
@@ -2926,6 +3433,14 @@ window.addEventListener('DOMContentLoaded', async () => {
            $('repoActionModal').classList.add('hidden');
        };
    }
+
+    try {
+        const queue = await window.electronAPI.getRetryQueue();
+        if (queue && queue.ok) {
+            updateRetryQueueBadge(queue.size || 0);
+            logActivity('info', `Retry-Queue geladen (${queue.size || 0} Einträge)`);
+        }
+    } catch (_) {}
    
    if ($('btnSaveSettings')) {
        $('btnSaveSettings').onclick = async () => {
@@ -2941,10 +3456,16 @@ window.addEventListener('DOMContentLoaded', async () => {
                featureColoredIcons = cbColorIcons2 ? cbColorIcons2.checked : true;
                document.body.classList.toggle('compact-mode', compactMode);

+                const checkedUrl = normalizeAndValidateGiteaUrl($('giteaURL').value);
+                if (!checkedUrl.ok) {
+                    showError(checkedUrl.error);
+                    return;
+                }
+
                const data = {
                    githubToken: $('githubToken').value,
                    giteaToken: $('giteaToken').value,
-                    giteaURL: $('giteaURL').value,
+                    giteaURL: checkedUrl.value,
                    featureFavorites,
                    featureRecent,
                    compactMode,
@@ -2955,6 +3476,12 @@ window.addEventListener('DOMContentLoaded', async () => {
                await window.electronAPI.saveCredentials(data);
                $('settingsModal').classList.add('hidden');
                showSuccess('Settings saved');
+                renderGiteaUrlHint(checkedUrl.value);
+                updateSettingsHealth({
+                    url: checkedUrl.value ? 'Gültig' : 'Leer',
+                    auth: data.giteaToken ? 'Token vorhanden' : 'Kein Token',
+                    lastError: '-'
+                });
                // Ansicht aktualisieren falls Feature-Flags geändert
                loadGiteaRepos();
            } catch (error) {
@@ -3087,6 +3614,30 @@ window.addEventListener('DOMContentLoaded', async () => {
        showProgress(p.percent, `Download: ${p.processed}/${p.total}`);
    });

+    if (window.electronAPI.onRetryQueueUpdated) {
+        window.electronAPI.onRetryQueueUpdated((payload) => {
+            const size = payload && typeof payload.size === 'number' ? payload.size : 0;
+            updateRetryQueueBadge(size);
+            if (payload && payload.event === 'queued' && payload.item) {
+                const p = payload.item.payload || {};
+                logActivity('warning', `Queue: ${p.owner}/${p.repo}/${p.path} wurde eingeplant`);
+            } else if (payload && payload.event === 'processed') {
+                logActivity('info', `Queue-Retry: ${payload.succeeded || 0} erfolgreich, ${payload.failed || 0} verworfen`);
+            }
+        });
+    }
+
+    if (window.electronAPI.onBatchActionProgress) {
+        window.electronAPI.onBatchActionProgress((payload) => {
+            if (!payload) return;
+            if (payload.status === 'running') {
+                logActivity('info', `Batch ${payload.action}: ${payload.repo} (${payload.index}/${payload.total})`);
+            } else if (payload.status === 'error') {
+                logActivity('error', `Batch ${payload.action}: ${payload.repo} - ${payload.error || 'Fehler'}`);
+            }
+        });
+    }
+
    // Setup globalen Drop-Handler für Repo-Ansicht
    setupGlobalDropZone();
    setupBackgroundContextMenu();
@@ -4424,9 +4975,16 @@ async function initUpdater() {
        if (versionRes && versionRes.ok && $('appVersion')) {
            $('appVersion').value = versionRes.version;
        }
+        if (versionRes && versionRes.ok && $('watermarkVersion')) {
+            $('watermarkVersion').textContent = versionRes.version;
+        }
    } catch (error) {
        console.error('[Renderer] Fehler beim Laden der Version:', error);
    }
+
+    if ($('watermarkCopyright')) {
+        $('watermarkCopyright').textContent = `© ${new Date().getFullYear()} M_Viper`;
+    }
    
    // Manueller Check Button in Settings
    if ($('btnCheckUpdates')) {