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 nach 30s, wenn keine Updates gefunden wurden.
    function checkAndCloseIfNoUpdates(doc, win) {
        const messageEl = doc.getElementById('updates-message');
        if (messageEl && messageEl.getAttribute('state') === 'none-found') {
            win.setTimeout(() => {
                try {
                    win.gBrowser.removeCurrentTab();
                } catch (e) {}
            }, 2000); // 30 Sekunden 30000
        }
    }

    // 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);

            /*
            win.setTimeout(function() {
                try {
                    const categories = doc.getElementById("categories");
                    if (categories) {
                        const availableBtn = categories.querySelector('button[viewid="addons://updates/available"]');
                        if (availableBtn) availableBtn.click();
                    }
                } catch (e) {}
                busy = false;
            }, 500); // Timeout auf 500ms erhöht für zuverlässigen Wechsel
            */
            } catch (e) {
            busy = false;
        }
    }
    /*
    function runOriginalAddonActions(doc, win) {
        try {
            const
                options = doc.querySelector("addon-page-options"), // Bereich für die Add-ons-Optionen.
                checkItem = doc.querySelector('panel-item[action="check-for-updates"]'), // Menüpunkt "Check for Updates".
                recentItem = doc.querySelector('panel-item[action="view-recent-updates"]'); // Menüpunkt "View Recent Updates".

            // Erst die Ansicht der letzten Updates öffnen.
            if (options && recentItem) {
                recentItem.click();
            }

            // Danach die 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
                        // Kategorie "recent updates" anklicken.
                        recentBtn = categories.querySelector('button[viewid="addons://updates/recent"]'),
                        // Kategorie "available updates" anklicken.
                        availableBtn = categories.querySelector('button[viewid="addons://updates/available"]');

                        if (recentBtn) recentBtn.click();
                        if (availableBtn) availableBtn.click();
                    }
                } catch (e) {}

                // Freigabe für neue Aktionen.
                busy = false;
            }, 50);   // 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)
                break;
        }

        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
                    );

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

    setTimeout(checkForUpdates, 10000);
})();