extensionsUpdateChecker.uc.js no longer works

// Atomatk-Addons-UpDate-Check.uc.js
// Das Script führt automatisch einen UpDate-Check aus und dies in einem neuen Tab anzeigt.
// Auch wird ein Button erstellt, der einen UpDate-Check ausführt und dies in einem neuen Tab anzeigt.

// Source file https://www.camp-firefox.de/forum/thema/140656/?postID=1290593#post1290593

/* ----------------------------------------------------------------------------------- */
/* Zu beachten ist, dass die Grafiken sich im richtigen Ordner befinden müssen */
/* %appdata%\Mozilla\Firefox\Profiles\"Profilname"\chrome\icons */
/* ----------------------------------------------------------------------------------- */

(function() {
"use strict";

    // Nur in einem normalen Browserfenster weiterarbeiten.
    if (!window.gBrowser) return;

    const
    // ■■ START UserConfiguration ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
             id = 'addons-update-button', // Id des Buttons
           link = 'about:addons', // Linkziel des Buttons
          label = 'Add-ons Update', // Bezeichnung des Buttons
    tooltiptext = 'Add-ons aktualisieren',
    // Icon-------------------------------------------------------
           icon = 'sync.svg', // [Name.Dateiendung] des Symbols
         colour = '#8bff0f', // Farbe für das SVG-Icon setzen
       iconPath = '/chrome/icons/', // Pfad zum Ordner der das Icon beinhaltet
    // ■■ END UserConfiguration ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
     curProfDir = PathUtils.toFileURI(PathUtils.join(PathUtils.profileDir));

    // SVG-Icons können CSS-Farbangaben übernehmen; das schaltet Firefox dafür frei.
	if (Services.prefs.getBoolPref('svg.context-properties.content.enabled') == false) {
		Services.prefs.setBoolPref('svg.context-properties.content.enabled', true );
	}

    const
    // ■■ START ScriptConfiguration ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
    STARTUP_DELAY_MS = 2500, // Verzögerung nach Firefox-Start, damit die Oberfläche fertig geladen ist.
         MAX_WAIT_MS = 12000, // Maximale Wartezeit darauf, dass about:addons vollständig geladen ist.
             POLL_MS = 250; // Intervall für wiederholte Prüfungen.
    let
         startupDone = false, // Merkt sich, ob der Startvorgang schon einmal ausgeführt wurde.
                busy = false; // Verhindert parallele Abläufe.
    // ■■ END ScriptConfiguration ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

    //BUTTON
	try {
      CustomizableUI.createWidget({
         id: id,
         defaultArea: CustomizableUI.AREA_NAVBAR,
         label: label,
         tooltiptext: tooltiptext,

         onCreated: (button) => {
            button.style.MozContextProperties = 'fill, stroke, fill-opacity';
            button.style.listStyleImage = 'url("' + curProfDir + iconPath + icon + '")';
            button.style.minWidth = 'fit-content';
          //  button.style.color = '#ffe10f'; // Farbe für das SVG-Icon setzen
            button.style.color = colour;
         }
      });
	} catch(e) {};
    // Liefert das aktuellste Browserfenster.
    function getBrowserWindow() {
        return Services.wm.getMostRecentWindow("navigator:browser");
    }
    // Öffnet about:addons in einem neuen Tab.
    function openAddonsTab(win) {
        if (!win) return false;
        try {
            win.openTrustedLinkIn(link, "tab");
        return true;
        } catch (e) {
            return false;
        }
    }

    // Schließt den Tab, wenn keine Updates gefunden wurden (mit robusterer Prüfung).
    function checkAndCloseIfNoUpdates(doc, win) {
        const startTime = Date.now();
        const MAX_CHECK_TIME = 10000; // 10 Sekunden maximale Wartezeit
        const CHECK_INTERVAL = 500;   // Alle 500ms prüfen

        function check() {
            try {
                // 1. Prüfe das klassische "no updates"-Element
                const messageEl = doc.getElementById('updates-message');
                if (messageEl && messageEl.getAttribute('state') === 'none-found') {
                    closeTabSafely(win);
                    return;
                }

                // 2. Prüfe, ob die "Available Updates"-Liste leer ist
                const availableUpdates = doc.querySelector('addon-list[filter="updates-available"]');
                if (availableUpdates && availableUpdates.items.length === 0) {
                    closeTabSafely(win);
                    return;
                }

                // 3. Prüfe auf Textindikatoren (z. B. "All add-ons are up to date")
                const noUpdatesText = doc.querySelector('.no-updates, [data-l10n-id="addon-updates-none-found"]');
                if (noUpdatesText) {
                    closeTabSafely(win);
                    return;
                }

                // 4. Wenn nichts gefunden wurde, aber die Zeit abgelaufen ist: Tab schließen
                if (Date.now() - startTime > MAX_CHECK_TIME) {
                    closeTabSafely(win);
                    return;
                }

                // Weiter prüfen
                win.setTimeout(check, CHECK_INTERVAL);
            } catch (e) {
                // Falls ein Fehler auftritt (z. B. Tab bereits geschlossen), abbrechen
                console.error('[AddonUpdateCheck] Fehler bei der Update-Prüfung:', e);
            }
        }

        // Hilfsfunktion: Tab sicher schließen (mit Fehlerbehandlung)
        function closeTabSafely(win) {
            try {
                if (win && win.gBrowser && win.gBrowser.removeCurrentTab) {
                    win.gBrowser.removeCurrentTab();
                }
            } catch (e) {
                console.warn('[AddonUpdateCheck] Tab konnte nicht geschlossen werden:', e);
            }
        }

        // Erste Prüfung nach 1 Sekunde starten (damit Firefox Zeit hat, die UI zu aktualisieren)
        win.setTimeout(check, 1000);
    }
    // Prüft, ob die Update-Elemente in about:addons schon vorhanden sind.
    function runOriginalAddonActions(doc, win) {
        try {
            const
            options = doc.querySelector("addon-page-options"),
            checkItem = doc.querySelector('panel-item[action="check-for-updates"]');
            // Update-Prüfung auslösen.
            if (options && checkItem) {
                checkItem.click();
            }
            // Kurz warten, damit Firefox die Ergebnisse sichtbar aufbauen kann.
            win.setTimeout(function() {
                try {
                    const categories = doc.getElementById("categories");
                    if (categories) {
                        const availableBtn = categories.querySelector('button[viewid="addons://updates/available"]');
                        if (availableBtn) availableBtn.click();
                        // 500ms warten, dann einmal prüfen
                        win.setTimeout(() => checkAndCloseIfNoUpdates(doc, win), 500);
                    }
                } catch (e) {}
                    busy = false;
            }, 500); // Timeout auf 500ms erhöht für zuverlässigen Wechsel // hier stand vorher 1500
        } catch (e) {
            busy = false;
        }
    }

    // Wartet, bis about:addons vollständig geladen ist.
    function waitForAboutAddons(win, fromStartup) {
        const started = Date.now();

        function tick() {
            let doc = null;
            try {
            doc = win.gBrowser.selectedBrowser.contentDocument;
            } catch (e) {}
            // Nur weitermachen, wenn about:addons wirklich geöffnet ist.
            if (doc && doc.URL === "about:addons") {
                try {
                    const
                    // Prüfen, ob die erwarteten UI-Elemente schon vorhanden sind.
                    options = doc.querySelector("addon-page-options"),
                    checkItem = doc.querySelector('panel-item[action="check-for-updates"]'),
                    recentItem = doc.querySelector('panel-item[action="view-recent-updates"]');

                    // Wenn alles da ist, die eigentliche Update-Logik starten.
                    if (options && checkItem && recentItem) {
                        runOriginalAddonActions(doc, win);
                        return;
                    }
                } catch (e) {}
            }
            // Weiter warten, solange das Zeitlimit nicht überschritten ist.
            if (Date.now() - started < MAX_WAIT_MS) {
                win.setTimeout(tick, POLL_MS);
            } else {
                // Wenn die Zeit abgelaufen ist, wieder freigeben.
                busy = false;

                // Beim Start nicht weiter forcieren.
                if (!fromStartup) {
                    openAddonsTab(win);
                }
            }
        }
        tick();
    }
    // Gemeinsame Hauptfunktion für Start und Button.
    function runCheck(fromStartup) {
        if (busy) return;
        busy = true;
        const win = getBrowserWindow();
        if (!win) { 
            busy = false;
            return;
        }
        // Erst Tab öffnen.
        if (!openAddonsTab(win)) { 
            busy = false;
            return;
        }
        // Danach auf fertige Seite warten.
        waitForAboutAddons(win, fromStartup);
    }
    // Startprüfung nur einmal ausführen.
    function runStartupCheck() {
        if (startupDone) return;
        startupDone = true;
        const win = getBrowserWindow();
        if (!win) return;
        // Kleine Verzögerung, damit Firefox vollständig bereit ist.
        win.setTimeout(function() { 
            runCheck(true);
        }, STARTUP_DELAY_MS);
    }
    // Observer für den Zeitpunkt, an dem Firefox die Fenster wiederhergestellt hat.
    function onWindowsRestored(subject, topic) {
        if (topic !== "sessionstore-windows-restored") return;
        try {
            Services.obs.removeObserver(onWindowsRestored, "sessionstore-windows-restored");
        } catch (e) {}
        runStartupCheck();
    }
    // Observer registrieren.
    try {
        Services.obs.addObserver(onWindowsRestored, "sessionstore-windows-restored");
    } catch (e) {
        // Falls der Observer nicht verfügbar ist, per Timer versuchen.
        window.setTimeout(runStartupCheck, STARTUP_DELAY_MS);
    }
    // Button-Klick-Handler einrichten.
    (function click_button() {
        const button = document.getElementById(id);
        if (button) {
            button.addEventListener("click", (event) => {
                // Nur linker Mausklick.
                if (event.button !== 0) return;
                // Das richtige Browserfenster ermitteln.
                const win = event.target.documentGlobal || event.target.ownerGlobal;
                // Keine parallelen Läufe.
                if (busy) return;
                busy = true;
                // Verhalten wie beim Start: Tab öffnen und dann prüfen.
                if (!openAddonsTab(win)) { 
                    busy = false;
                    return;
                }
                waitForAboutAddons(win, false);
            });
        } else {
        // Wenn der Button noch nicht existiert, erneut probieren.
        setTimeout(click_button, 100);
        }
    })();

})();

// addonUpdateNotifier.uc.js
// Firefox 152+

(async function() {
    if (location.href !== "chrome://browser/content/browser.xhtml")
        return;

    const { AddonManager } =
        ChromeUtils.importESModule ("resource://gre/modules/AddonManager.sys.mjs");

    async function checkForUpdates() {
        let foundUpdate = false;
        let addons = await AddonManager.getAddonsByTypes(["extension"]);

        for (let addon of addons) {
            if (!(addon.permissions & AddonManager.PERM_CAN_UPGRADE))
                continue;

            await new Promise(resolve => {
                addon.findUpdates({
                    onUpdateAvailable(aAddon, install) {
                        foundUpdate = true;
                    },
                    onNoUpdateAvailable() {},
                    onUpdateFinished() {
                        resolve();
                    }
                }, AddonManager.UPDATE_WHEN_USER_REQUESTED);
            });
        }
        if (foundUpdate) {
            let win = Services.wm.getMostRecentWindow("navigator:browser");
            let tab = win.gBrowser.addTrustedTab("about:addons");

            tab.linkedBrowser.addEventListener(
                "DOMContentLoaded",
                function listener() {
                    tab.linkedBrowser.removeEventListener(
                        "DOMContentLoaded",
                        listener
                    );
                    tab.linkedBrowser.loadURI(
                        Services.io.newURI(
                            "about:addons#updates"
                        )
                    );
                },
                { once: true }
            );
        }
    }
    setTimeout(checkForUpdates, 2000);
})();

// AddonSuche4.uc.js
// Firefox 152+

(async function () {
    if (location.href !== "chrome://browser/content/browser.xhtml")
        return;

    var AddonManager = ChromeUtils.importESModule(
        "resource://gre/modules/AddonManager.sys.mjs"
    ).AddonManager;

    function findUpdatesForAddon(addon) {
        return new Promise(function (resolve) {
            var hasUpdate = false;

            addon.findUpdates({
                onUpdateAvailable: function (aAddon, install) {
                    hasUpdate = true;
                },

                onNoUpdateAvailable: function () {
                },

                onUpdateFinished: function () {
                    resolve(hasUpdate);
                }
            }, AddonManager.UPDATE_WHEN_USER_REQUESTED);
        });
    }

    async function checkForUpdates() {
        await AddonManager.readyPromise;

        var updates = [];
        var addons = await AddonManager.getAllAddons();

        for (var i = 0; i < addons.length; i++) {
            var addon = addons[i];

            if (addon.type !== "extension")
                continue;

            if (!(addon.permissions & AddonManager.PERM_CAN_UPGRADE))
                continue;

            var hasUpdate = await findUpdatesForAddon(addon);

            if (hasUpdate) {
                updates.push({
                    id: addon.id,
                    name: addon.name,
                    disabled: !!(addon.userDisabled || addon.appDisabled)
                });
            }
        }

        if (!updates.length)
            return;

        console.log(
            "Gefundene Add-on-Updates:",
            updates.map(function (u) {
                return u.name + (u.disabled ? " (deaktiviert)" : "");
            })
        );

        var win = Services.wm.getMostRecentWindow("navigator:browser");
        if (!win || !win.gBrowser)
            return;

        var tab = win.gBrowser.addTrustedTab("about:addons");

        // Tab in den Vordergrund holen
        win.gBrowser.selectedTab = tab;
        win.focus();

        // Erst den normalen about:addons-Zustand laden, dann auf Updates umschalten.
        tab.linkedBrowser.addEventListener(
            "DOMContentLoaded",
            function listener() {
                tab.linkedBrowser.removeEventListener(
                    "DOMContentLoaded",
                    listener
                );

                tab.linkedBrowser.loadURI(
                    Services.io.newURI("about:addons#updates")
                );
            },
            { once: true }
        );
    }

    setTimeout(checkForUpdates, 2000);
})();