wichtiges UPDATE für controller 7.2.2 im stable

[Michael Schmitt]

Hi,
hab den oberen Post editiert und das Javascript nochmal ändern lassen.

// ======================================================
// 1. KONFIGURATION (Hier alle Einstellungen vornehmen)
// ======================================================

// Hier die gewünschte Telegram-Instanz eintragen (Standard: "telegram.0")
const TELEGRAM_INSTANCE = "telegram.0";

// Hier den exakten Telegram-Benutzernamen eintragen, der die Nachrichten erhalten soll.
// WICHTIG: Soll die Nachricht an ALLE angemeldeten Geräte oder Gruppen gesendet werden,
// trage hier einfach zwei doppelte Anführungszeichen "" ein (komplett leer lassen).
const TELEGRAM_USER = "HierEuerenUserRein";

// Liste von Adaptern, die komplett von der Überwachung ausgenommen werden sollen.
// Der Filter prüft auf den Anfang des Instanznamens (Prefix).
// BEISPIELE für die Nutzung:
// const ignorePrefixes = ["ping.", "fb-checkpresence."]; -> Ignoriert alle Ping- und Fritzbox-Instanzen
// const ignorePrefixes = ["alexa2.0"]; -> Ignoriert gezielt nur die erste Alexa-Instanz
const ignorePrefixes = [];

// Einstellbare Timer-Verzögerungen (Timeouts in Millisekunden)
const DELAY_OFFLINE = 30 * 1000;      // Wartezeit vor einem Rot-Alarm (Prozess offline)
const DELAY_CONNECTION = 30 * 1000;   // Wartezeit vor einem Gelb-Alarm (Verbindungsverlust)
const DELAY_ONLINE = 30 * 1000;       // Stabilisierungszeit vor einem Grün-Alarm (Entwarnung)

// Alarm-Sperrzeiten (Flap-Guard / Flatterschutz)
const ALERT_SUPPRESSION = 90 * 1000;  // Mindestabstand zwischen zwei Fehlermeldungen desselben Adapters
const ONLINE_SUPPRESSION = 5 * 60 * 1000; // Mindestabstand zwischen zwei Entwarnungen desselben Adapters

// Aufbewahrungszeit der Alarm-Historie im RAM-Speicher (1 Stunde)
const HISTORY_RETENTION = 60 * 60 * 1000;

// ======================================================
// 2. SPEICHER & CACHE
// ======================================================

const monitorState = {
    timeoutsAbsturz: {},
    timeoutsWiederstart: {},
    timeoutsVerbindung: {},
    lastAlertOffline: {},
    lastAlertOnline: {},
    lastAlertYellow: {}
};

const scheduleAdapterCache = {};
let isCacheReady = false;

// ======================================================
// PRELOADER (Sicherer RAM-Preload über den State-Selektor)
// ======================================================

function preloadScheduleAdapters() {
    try {
        // Findet alle echten Instanzen über deren systemweiten .alive-Datenpunkt
        const aliveStates = $('system.adapter.*.*.alive');
        
        aliveStates.each((id) => {
            const inst = id.replace("system.adapter.", "").replace(".alive", "");
            const configObj = getObject("system.adapter." + inst);
            
            if (configObj) {
                scheduleAdapterCache[inst] = configObj.common?.mode === "schedule";
            }
        });

        isCacheReady = true;
        log(`Adapter-Monitor: Cache erfolgreich geladen (${Object.keys(scheduleAdapterCache).length} Instanzen)`, "info");

    } catch (e) {
        log("Adapter-Monitor: Preload-Fehler im System: " + e, "warn");
        isCacheReady = true;
    }
}

preloadScheduleAdapters();

// ======================================================
// GC (Garbage Collector für die Historie)
// ======================================================

setInterval(() => {
    const now = Date.now();

    for (const group of [
        monitorState.lastAlertOffline,
        monitorState.lastAlertOnline,
        monitorState.lastAlertYellow
    ]) {
        for (const k in group) {
            if (now - group[k] > HISTORY_RETENTION) {
                delete group[k];
            }
        }
    }
}, 15 * 60 * 1000);
// ======================================================
// HELPERS
// ======================================================

function clearMonitorTimeout(obj, key) {
    if (obj[key]) {
        clearTimeout(obj[key]);
        delete obj[key];
    }
}

function triggerYellowAlert(inst) {
    const now = Date.now();
    if (now - (monitorState.lastAlertYellow[inst] || 0) < ALERT_SUPPRESSION) return;

    sendTelegram(
`⚠️ *ioBroker Status-Warnung* ⚠️
───────────────────
• *Adapter:* \`${inst}\`
• *Status:* \`keine Verbindung (Gelb)\`
• *Zeit:* ${formatDate(new Date(), "hh:mm")} Uhr
───────────────────
🔌 _Der Prozess läuft, aber die Verbindung zum Gerät oder Cloud-Dienst ist gestört!_`
    );

    monitorState.lastAlertYellow[inst] = now;
    log("Adapter-Zustand: " + inst + " hat keine Verbindung (Gelb)", "info");
}

function isScheduleAdapter(inst) {
    if (scheduleAdapterCache[inst] === undefined) {
        const configObj = getObject("system.adapter." + inst);

        scheduleAdapterCache[inst] =
            configObj &&
            configObj.common &&
            configObj.common.mode === "schedule";
    }

    return scheduleAdapterCache[inst] === true;
}

function safeGetState(id) {
    try {
        return getState(id) || null;
    } catch (e) {
        return null;
    }
}

function sendTelegram(text) {
    const telegramOptions = {
        text: text,
        parse_mode: "Markdown"
    };
    
    // Nur filtern, wenn ein spezifischer Benutzername oben eingetragen wurde
    if (TELEGRAM_USER && TELEGRAM_USER.trim() !== "") {
        telegramOptions.user = TELEGRAM_USER;
    }

    sendTo(TELEGRAM_INSTANCE, telegramOptions);
}

// ======================================================
// MAIN HANDLER (Live-Event-Überwachung)
// ======================================================

on({ id: /^system\.adapter\..*\.(alive|connection)$/, change: "ne" }, handleAdapterChange);
on({ id: /^([a-zA-Z0-9._\-]+)\.\d+\.info\.connection$/, change: "ne" }, handleAdapterChange);

function handleAdapterChange(obj) {

    if (!isCacheReady) return;
    if (!obj?.state || !obj?.oldState) return;
    if (typeof obj.state.val !== "boolean") return;

    const status = obj.state.val;
    const previous = obj.oldState.val;
    let inst = "";
    let type = "";

    if (obj.id.startsWith("system.adapter.")) {
        const match = obj.id.match(/^system\.adapter\.([a-zA-Z0-9._\-]+)\.(alive|connection)$/);
        if (!match) return;
        inst = match[1];
        type = match[2];
    } else {
        const match = obj.id.match(/^(([a-zA-Z0-9._\-]+)\.\d+)\.info\.connection$/);
        if (!match) return;
        inst = match[1];
        type = "connection";
    }

    if (ignorePrefixes.some(p => inst.startsWith(p))) return;

    // ==================================================
    // 🔴 CRASH (Prozess offline)
    // ==================================================
    if (type === "alive" && status === false && previous === true) {

        clearMonitorTimeout(monitorState.timeoutsWiederstart, inst);
        clearMonitorTimeout(monitorState.timeoutsAbsturz, inst);
        clearMonitorTimeout(monitorState.timeoutsVerbindung, inst);

        monitorState.timeoutsAbsturz[inst] = setTimeout(() => {
            delete monitorState.timeoutsAbsturz[inst];
            if (isScheduleAdapter(inst)) return;

            const alive = safeGetState("system.adapter." + inst + ".alive");
            if (!alive || alive.val !== false) return;

            const now = Date.now();
            if (now - (monitorState.lastAlertOffline[inst] || 0) < ALERT_SUPPRESSION) return;

            sendTelegram(
`🚨 *ioBroker System-Warnung* 🚨
───────────────────
• *Adapter:* \`${inst}\`
• *Status:* \`offline (Prozess tot)\`
• *Zeit:* ${formatDate(new Date(), "hh:mm")} Uhr
───────────────────
⚠️ _Der Instanz-Prozess ist unerwartet abgestürzt oder wurde gestoppt!_`
            );

            monitorState.lastAlertOffline[inst] = now;
            log("Adapter-Zustand: " + inst + " ist offline (Rot)", "info"); 

        }, DELAY_OFFLINE);
    }

    // ==================================================
    // 🟡 CONNECTION LOSS (Verbindungsverlust)
    // ==================================================
    else if (type === "connection" && status === false && previous === true) {

        clearMonitorTimeout(monitorState.timeoutsWiederstart, inst);
        clearMonitorTimeout(monitorState.timeoutsVerbindung, inst);
        clearMonitorTimeout(monitorState.timeoutsAbsturz, inst);

        monitorState.timeoutsVerbindung[inst] = setTimeout(() => {
            delete monitorState.timeoutsVerbindung[inst];

            const alive = safeGetState("system.adapter." + inst + ".alive");
            if (!alive || alive.val !== true) return;
            
            const sysConnId = "system.adapter." + inst + ".connection";
            const infoConnId = inst + ".info.connection";
            
            const sysConn = existsState(sysConnId) ? safeGetState(sysConnId) : null;
            const infoConn = existsState(infoConnId) ? safeGetState(infoConnId) : null;
            
            if ((sysConn && sysConn.val === true) && (!infoConn || infoConn.val === true)) return;

            triggerYellowAlert(inst);

        }, DELAY_CONNECTION);
    }

    // ==================================================
    // 🟢 RECOVERY / START LOGIK (Entwarnung)
    // ==================================================
    else if ((type === "alive" || type === "connection") && status === true && previous === false) {

        clearMonitorTimeout(monitorState.timeoutsWiederstart, inst);
        clearMonitorTimeout(monitorState.timeoutsAbsturz, inst);
        clearMonitorTimeout(monitorState.timeoutsVerbindung, inst);

        monitorState.timeoutsWiederstart[inst] = setTimeout(() => {
            delete monitorState.timeoutsWiederstart[inst];

            const alive = safeGetState("system.adapter." + inst + ".alive");
            if (!alive || alive.val !== true) return;

            const sysConnId = "system.adapter." + inst + ".connection";
            const infoConnId = inst + ".info.connection";

            const sysConn = existsState(sysConnId) ? safeGetState(sysConnId) : null;
            const infoConn = existsState(infoConnId) ? safeGetState(infoConnId) : null;

            if ((sysConn && sysConn.val === false) || (infoConn && infoConn.val === false)) {
                
                if (!monitorState.timeoutsVerbindung[inst]) {
                    monitorState.timeoutsVerbindung[inst] = setTimeout(() => {
                        delete monitorState.timeoutsVerbindung[inst];
                        
                        const currentAlive = safeGetState("system.adapter." + inst + ".alive");
                        const currentSys = existsState(sysConnId) ? safeGetState(sysConnId) : null;
                        const currentInfo = existsState(infoConnId) ? safeGetState(infoConnId) : null;
                        
                        if (currentAlive && currentAlive.val === true) {
                            if ((currentSys && currentSys.val === false) || (currentInfo && currentInfo.val === false)) {
                                triggerYellowAlert(inst);
                            }
                        }
                    }, DELAY_CONNECTION);
                }
                return;
            }

            if (isScheduleAdapter(inst)) return;

            const hadOffline = monitorState.lastAlertOffline[inst];
            const hadYellow  = monitorState.lastAlertYellow[inst];

            if (hadOffline === undefined && hadYellow === undefined) return;

            const now = Date.now();
            if (now - (monitorState.lastAlertOnline[inst] || 0) < ONLINE_SUPPRESSION) return;

            delete monitorState.lastAlertOffline[inst];
            delete monitorState.lastAlertYellow[inst];

            sendTelegram(
`✅ *ioBroker Entwarnung* ✅
───────────────────
• *Adapter:* \`${inst}\`
• *Status:* \`online (Grün)\`
• *Zeit:* ${formatDate(new Date(), "hh:mm")} Uhr
───────────────────
👍 _Die Instanz läuft wieder vollständig stabil._`
            );

            monitorState.lastAlertOnline[inst] = now;
            log("Adapter-Zustand: " + inst + " ist wieder stabil online (Grün)", "debug"); 

            clearMonitorTimeout(monitorState.timeoutsAbsturz, inst);
            clearMonitorTimeout(monitorState.timeoutsVerbindung, inst);

        }, DELAY_ONLINE);
    }
}

[RISSN]

ich korrigiere mich, nach tatsächlich ein paar Tagen, ist der Adapter wieder gelb geworden und lief nicht mehr, also zu früh gefreut

[Michael Schmitt]

@bluefox gibt es zu dem Thema Alexa2 + cookie schon etwas neues ?

[com27]

Würde mich auch Interessieren, da ich sehr viele Meldungen über Alexa Sprachausgabe schicke. Müsste sonst wechseln zu Home Assistant.

[Dr. Bakterius]

@com27 sagte:

Müsste sonst wechseln zu Home Assistant.

Da bleibt die Verbindung zu Amazon aufrecht? Und ich glaube, @apollon77 ist für Nachfragen der richtige Ansprechpartner. Er arbeitet sicher bereits an einer Lösung...

[Samson71]

@Dr.-Bakterius sagte:
Da bleibt die Verbindung zu Amazon aufrecht?

Tut sie, zumindest wenn man die offizielle Nabu Casa Integration nutzt. Wie das bei den DIY-/Selfhost-Lösungen aussieht weis ich natürlich nicht.

[mayer]

Ich habe im Issue 1376 den Lösungsansatz und die notwendigen Codeänderungen, welche mir die KI die ich selber zum programmieren nutze ausgespuckt hat, ergänzt. Vielleicht hilft es ja: Cookie refresh scheint nicht mehr zu funktionieren #1376

[da_Woody]

mädelz, hört auf mit jammern. das problem ist im moment da. thats it. musste mich auch gerade neu anmelden.
es wird daran gewerkelt, wait n c...

[mayer]

Das Problem gibt es schon seit über 3 Wochen und keiner jammert sondern wartet auf eine Lösung. Bis jetzt wurde nur an den Symptomen gebastelt, aber nicht an der Ursache. Kann ja sein, dass eine funktionierende Sprachausgabe über Alexa nicht wichtig ist für Sie. Für mich ist es wichtig und wenn es keine Lösung gibt, fixe ich mir den Adapter für mich eben selber.

[Ro75]

@mayer sagte:

aber nicht an der Ursache.

Es tut mir leid, aber die Ursache ist Amazon. Und ja, es ist gerade schwer, aber wenn du Lösungen schaffen kannst, dann mache es – davon können wir hier leben.

Kleiner Hinweis: Auch ich habe mich mit dem Thema Login, Cookies, Erneuerung usw. beschäftigt. Aber ganz so trivial ist es nicht.

Ro75.

[Dr. Bakterius]

@mayer sagte:

Vielleicht hilft es ja

Bei mir klappt das leider nicht. Habe es 2x versucht. Ich erhalte:

2026-06-29 14:50:22.137 - error: alexa2.0 (327852) uncaught exception: minCookieRefreshAge is not defined
2026-06-29 14:50:22.138 - error: alexa2.0 (327852) ReferenceError: minCookieRefreshAge is not defined
at getCookie (/opt/iobroker/node_modules/alexa-remote2/alexa-remote.js:231:60)
at AlexaRemote.init (/opt/iobroker/node_modules/alexa-remote2/alexa-remote.js:253:9)
at main (/opt/iobroker/node_modules/iobroker.alexa2/main.js:5115:11)
at Immediate. (/opt/iobroker/node_modules/iobroker.alexa2/main.js:629:9)
at processImmediate (node:internal/timers:506:21)
2026-06-29 14:50:22.138 - error: alexa2.0 (327852) minCookieRefreshAge is not defined
2026-06-29 14:50:22.150 - info: alexa2.0 (327852) terminating
2026-06-29 14:50:22.150 - warn: alexa2.0 (327852) Terminated (UNCAUGHT_EXCEPTION): Without reason
2026-06-29 14:50:22.651 - info: alexa2.0 (327852) terminating
2026-06-29 14:50:22.652 - info: alexa2.0 (327852) terminating
2026-06-29 14:50:22.719 - error: host.iobroker instance system.adapter.alexa2.0 terminated with code 6 (UNCAUGHT_EXCEPTION)
2026-06-29 14:50:54.294 - error: alexa2.0 (327995) adapter disabled
2026-06-29 14:50:54.339 - warn: alexa2.0 (327995) Terminated (NO_ADAPTER_CONFIG_FOUND): Without reason
2026-06-29 14:50:54.880 - error: host.iobroker instance system.adapter.alexa2.0 terminated with code 3 (NO_ADAPTER_CONFIG_FOUND)

[mayer]

@Dr.-Bakterius
Anleitung zum Beheben des Fehlers im MD-File.
alexa2_cookie_refresh_patch_anleitung.md

[Ro75]

Jeder kann ja machen was er will! Man sollte sich schon sicher sein, wie Amazon mit Logins, Aktualisierungen, erneuten Anfragen etc. umgeht. Im besten Fall wirst du nur für eine Zeitlang gesperrt. Im schlimmsten Fall kannste sehen wie du deinen Account reaktiviert bekommst. Es hat schon einen Sinn, das ganze eben nicht aller 12 Stunden zu machen.

Ro75.

[mayer]

@Ro75
Die Codeänderungen sind nur Vorschläge und sollen helfen das Problem einzugrenzen. Keiner muss das machen.
Zu den Bedenken wegen der Cookie Request Zeitspanne. Ganz unberechtigt sind die nicht, aber:

Meine Einschätzung: 12 Stunden ist ein guter Testwert, aber für Dauerbetrieb würde ich eher auf 18 oder 24 Stunden gehen, sobald klar ist, dass der Fix stabil läuft. Wenn Amazon bei dir nach 48 Stunden aussteigt, wäre 24 Stunden wahrscheinlich ausreichend. Wenn es eher nach 24–36 Stunden passiert, sind 12 oder 18 Stunden sicherer.

Ich würde praktisch so vorgehen: erst 12 Stunden für 3–5 Tage testen, danach bei stabilem Betrieb auf 18 Stunden erhöhen. Das reduziert Amazon-Requests, bleibt aber deutlich unter der beobachteten Ablaufzeit.

[Dr. Bakterius]

@mayer sagte:

Anleitung zum Beheben des Fehlers im MD-File.

Danke, jetzt startet der Adapter. Ich bin aber auf 20 statt 12 Stunden gegangen. Mal sehen ob es etwas bringt.

[Ro75]

@mayer sagte:

sind nur Vorschläge

Folgendes solltest du nur bedenken. Sobald du etwas öffentlich machst, "stürzen" sich die "Anwender" auch drauf. Die lesen nicht das es Risiken geben kann - und ich habe da auch nichts gelesen. Die machen einfach.

Dann ist das Geschrei groß. "Der Adapter" hat mir den Account gesperrt. Jetzt geht gar nichts mehr! Und auf die Frage: Was hast du gemacht. Na nichts. Und schon laufen sich die Hilfeleistenden hier den Wolf.

Ro75.

[Dr. Bakterius]

@Ro75 sagte:

Die lesen nicht das es Risiken geben kann

Ich denke, bei knapp 24 Stunden ist das Risiko eher klein. Müssen doch viele ohnehin nach dieser Zeit sich neu anmelden damit der Adapter wieder läuft. Hätten die dann nicht alle schon eine Sperre erhalten?

[Ro75]

@Dr.-Bakterius sagte:

Müssen doch viele ohnehin nach dieser Zeit

Nein, eben nicht. Bei mir etwa nach 60 bis 72 Stunden. Deswegen. So trivial ist das nicht.

Ro75.