console-error-scanner 1.16.3__py3-none-any.whl

console_error_scanner/models/robots.py

@@ -0,0 +1,154 @@
+"""robots.txt-Auswertung: prueft, ob eine Seite abgerufen werden darf.
+
+Geprueft werden nur die SEITEN aus der Sitemap. Ressourcen, die eine Seite
+nachlaedt (Bilder, Skripte), werden bewusst nicht geprueft: sie liegen oft auf
+einer CDN-Domain mit eigener robots.txt, und wer die Seite ausliefern darf,
+liefert ihre Ressourcen ohnehin mit aus.
+
+Ausgewertet wird nur der `User-agent: *`-Block; der Scanner tritt nicht unter
+einem eigenen Bot-Namen auf.
+"""
+
+from __future__ import annotations
+
+import re
+from urllib.parse import urlparse, urlunparse
+
+import httpx
+
+
+def _compile_pattern(pattern: str) -> re.Pattern[str]:
+    """Uebersetzt ein robots-Pfadmuster in eine Regex.
+
+    Der Standard (RFC 9309) kennt zwei Sonderzeichen: `*` fuer eine beliebige
+    Zeichenfolge und `$` am Ende fuer "Pfad endet hier". Ohne diese Behandlung
+    greifen reale Regeln wie `Disallow: /*CR-Dokumentation.pdf$` nie, weil kein
+    Pfad buchstaeblich mit `/*CR-` beginnt.
+
+    Args:
+        pattern:
+        Pfadmuster aus einer Disallow-/Allow-Zeile.
+
+    Returns:
+        Kompilierte Regex, die am Pfadanfang ankert.
+    """
+    anchored_end = pattern.endswith("$")
+    raw = pattern[:-1] if anchored_end else pattern
+    body = "".join(".*" if char == "*" else re.escape(char) for char in raw)
+    return re.compile(f"^{body}$" if anchored_end else f"^{body}")
+
+
+class RobotsChecker:
+    """Laedt und parst die robots.txt einer Domain (Disallow/Allow)."""
+
+    def __init__(self) -> None:
+        # (Musterlaenge, kompiliertes Muster, erlaubt) - die Laenge entscheidet,
+        # welche Regel bei mehreren Treffern gewinnt (spezifischste zuerst).
+        self._rules: list[tuple[int, re.Pattern[str], bool]] = []
+        self._loaded = False
+
+    async def load(
+        self,
+        base_url: str,
+        cookies: list[dict[str, str]] | None = None,
+        proxy: str = "",
+        client: httpx.AsyncClient | None = None,
+    ) -> None:
+        """Laedt die robots.txt zur angegebenen URL.
+
+        Nicht erreichbar oder kein 200 = keine Regeln = alles erlaubt. Das ist
+        bewusst die freundliche Auslegung: ein fehlendes robots.txt ist keine
+        Sperre.
+
+        Args:
+            base_url:
+            Beliebige URL der Zieldomain; daraus wird /robots.txt abgeleitet.
+            cookies:
+            Optionale Cookies (z.B. fuer geschuetzte Testsysteme).
+            proxy:
+            Optionale Proxy-URL (Corporate-Proxy/Zscaler).
+            client:
+            Optionaler, bereits konfigurierter Client - sonst wird einer
+            geoeffnet. Dient vor allem der Testbarkeit ohne Netzwerk.
+        """
+        parsed = urlparse(base_url)
+        robots_url = urlunparse((parsed.scheme, parsed.netloc, "/robots.txt", "", "", ""))
+
+        try:
+            if client is not None:
+                response = await client.get(robots_url)
+                if response.status_code == 200:
+                    self._parse(response.text)
+            else:
+                jar = httpx.Cookies()
+                for cookie in cookies or []:
+                    jar.set(cookie["name"], cookie["value"])
+                async with httpx.AsyncClient(
+                    timeout=10.0,
+                    follow_redirects=True,
+                    verify=False,
+                    cookies=jar,
+                    proxy=proxy.strip() or None,
+                ) as own_client:
+                    response = await own_client.get(robots_url)
+                    if response.status_code == 200:
+                        self._parse(response.text)
+        except Exception:  # noqa: BLE001 - robots.txt ist optional
+            pass
+        self._loaded = True
+
+    def _parse(self, text: str) -> None:
+        """Parst Disallow/Allow aus dem `User-agent: *`-Block."""
+        in_wildcard_block = False
+
+        for raw_line in text.splitlines():
+            line = raw_line.strip()
+            if "#" in line:
+                line = line[: line.index("#")].strip()
+            if not line:
+                continue
+
+            lower = line.lower()
+            if lower.startswith("user-agent:"):
+                in_wildcard_block = line[len("user-agent:") :].strip() == "*"
+                continue
+            if not in_wildcard_block:
+                continue
+
+            if lower.startswith("disallow:"):
+                path = line[len("disallow:") :].strip()
+                if path:  # "Disallow:" ohne Pfad heisst: alles erlaubt
+                    self._rules.append((len(path), _compile_pattern(path), False))
+            elif lower.startswith("allow:"):
+                path = line[len("allow:") :].strip()
+                if path:
+                    self._rules.append((len(path), _compile_pattern(path), True))
+
+    def is_allowed(self, url: str) -> bool:
+        """Prueft, ob die URL abgerufen werden darf.
+
+        Bei mehreren passenden Regeln gewinnt die laengste (spezifischste); bei
+        gleicher Laenge gewinnt Allow - so schreibt es RFC 9309 vor.
+        """
+        if not self._rules:
+            return True
+
+        parsed = urlparse(url)
+        path = parsed.path or "/"
+        if parsed.query:
+            path = f"{path}?{parsed.query}"
+
+        best_length = -1
+        allowed = True
+        for length, pattern, rule_allows in self._rules:
+            if not pattern.search(path):
+                continue
+            if length > best_length or (length == best_length and rule_allows):
+                best_length = length
+                allowed = rule_allows
+        return allowed
+
+    @property
+    def is_loaded(self) -> bool:
+        """Gibt zurueck, ob ein Ladeversuch stattgefunden hat."""
+        return self._loaded

console_error_scanner/models/scan_result.py

@@ -0,0 +1,265 @@
+"""Datenmodelle fuer Scan-Ergebnisse."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+
+
+class ErrorType(Enum):
+    """Art des Fehlers."""
+
+    CONSOLE_ERROR = "console_error"
+    CONSOLE_WARNING = "console_warning"
+    HTTP_404 = "http_404"
+    HTTP_4XX = "http_4xx"
+    HTTP_5XX = "http_5xx"
+
+
+class PageStatus(Enum):
+    """Status einer gescannten Seite."""
+
+    PENDING = "pending"
+    SCANNING = "scanning"
+    OK = "ok"
+    WARNING = "warning"
+    ERROR = "error"
+    TIMEOUT = "timeout"
+
+
+@dataclass
+class PageError:
+    """Ein einzelner Fehler auf einer Seite."""
+
+    error_type: ErrorType
+    message: str
+    source: str = ""
+    line_number: int = 0
+    whitelisted: bool = False
+
+    def to_dict(self) -> dict:
+        """Konvertiert den Fehler in ein Dictionary."""
+        return {
+            "error_type": self.error_type.value,
+            "message": self.message,
+            "source": self.source,
+            "line_number": self.line_number,
+            "whitelisted": self.whitelisted,
+        }
+
+
+@dataclass
+class ResourceSize:
+    """Eine einzelne geladene Ressource mit ihrer Transfergroesse.
+
+    Dient dem "Diaet-Ratgeber" (groesste Brocken einer Seite).
+    """
+
+    url: str
+    size_bytes: int
+    resource_type: str = ""
+
+    def to_dict(self) -> dict:
+        """Konvertiert die Ressource in ein Dictionary."""
+        return {
+            "url": self.url,
+            "size_bytes": self.size_bytes,
+            "resource_type": self.resource_type,
+        }
+
+
+@dataclass
+class ScanResult:
+    """Ergebnis des Scans einer einzelnen Seite."""
+
+    url: str
+    status: PageStatus = PageStatus.PENDING
+    http_status_code: int = 0
+    # Ladezeit: Browser-Load-Event (Navigation Timing 'loadEventEnd'), Fallback
+    # auf die Wall-Clock-Messung goto->networkidle. Siehe Scanner.
+    load_time_ms: int = 0
+    # DOMContentLoaded-Zeit (Navigation Timing 'domContentLoadedEventEnd'), ms.
+    dom_content_loaded_ms: int = 0
+    # Anzahl ALLER Requests der Seite (wie Edge-Netzwerkmonitor).
+    request_count: int = 0
+    page_size_bytes: int = 0
+    errors: list[PageError] = field(default_factory=list)
+    retry_count: int = 0
+    # HTTP-Response-Daten der Hauptseite (Document)
+    response_headers: dict[str, str] = field(default_factory=dict)
+    content_type: str = ""
+    last_modified: str = ""
+    # Groesste Einzelressourcen (same-host), absteigend - fuer den Diaet-Ratgeber.
+    resource_sizes: list[ResourceSize] = field(default_factory=list)
+
+    @property
+    def console_error_count(self) -> int:
+        """Anzahl der Console-Errors (ohne whitelisted)."""
+        return sum(1 for e in self.errors if e.error_type == ErrorType.CONSOLE_ERROR and not e.whitelisted)
+
+    @property
+    def console_warning_count(self) -> int:
+        """Anzahl der Console-Warnings (ohne whitelisted)."""
+        return sum(1 for e in self.errors if e.error_type == ErrorType.CONSOLE_WARNING and not e.whitelisted)
+
+    @property
+    def http_404_count(self) -> int:
+        """Anzahl der HTTP 404 Fehler (ohne whitelisted)."""
+        return sum(1 for e in self.errors if e.error_type == ErrorType.HTTP_404 and not e.whitelisted)
+
+    @property
+    def http_4xx_count(self) -> int:
+        """Anzahl der HTTP 4xx Fehler ohne 404 (ohne whitelisted)."""
+        return sum(1 for e in self.errors if e.error_type == ErrorType.HTTP_4XX and not e.whitelisted)
+
+    @property
+    def http_5xx_count(self) -> int:
+        """Anzahl der HTTP 5xx Fehler (ohne whitelisted)."""
+        return sum(1 for e in self.errors if e.error_type == ErrorType.HTTP_5XX and not e.whitelisted)
+
+    # Fehlertypen die als "echter Fehler" (ERR) zaehlen
+    _ERROR_TYPES = {ErrorType.CONSOLE_ERROR, ErrorType.HTTP_404, ErrorType.HTTP_4XX, ErrorType.HTTP_5XX}
+
+    @property
+    def has_errors(self) -> bool:
+        """Hat die Seite nicht-whitelisted echte Fehler (ohne Warnings)?"""
+        return any(e.error_type in self._ERROR_TYPES and not e.whitelisted for e in self.errors)
+
+    @property
+    def has_issues(self) -> bool:
+        """Hat die Seite irgendwelche nicht-whitelisted Eintraege (inkl. Warnings)?"""
+        return any(not e.whitelisted for e in self.errors)
+
+    @property
+    def ignored_count(self) -> int:
+        """Anzahl der per Whitelist ignorierten Fehler."""
+        return sum(1 for e in self.errors if e.whitelisted)
+
+    @property
+    def has_only_ignored_errors(self) -> bool:
+        """Hat die Seite nur whitelisted Fehler (keine echten Issues)?"""
+        return len(self.errors) > 0 and not self.has_issues
+
+    @property
+    def status_icon(self) -> str:
+        """Icon fuer den aktuellen Status."""
+        if self.has_only_ignored_errors:
+            return "IGN"
+        icons = {
+            PageStatus.PENDING: "...",
+            PageStatus.SCANNING: ">>>",
+            PageStatus.OK: "OK",
+            PageStatus.WARNING: "WARN",
+            PageStatus.ERROR: "ERR",
+            PageStatus.TIMEOUT: "T/O",
+        }
+        return icons.get(self.status, "?")
+
+    @property
+    def total_error_count(self) -> int:
+        """Gesamtanzahl aller nicht-whitelisted Fehler."""
+        return sum(1 for e in self.errors if not e.whitelisted)
+
+    def to_dict(self) -> dict:
+        """Konvertiert das Ergebnis in ein Dictionary."""
+        active_errors = [e for e in self.errors if not e.whitelisted]
+        ignored_errors = [e for e in self.errors if e.whitelisted]
+        return {
+            "url": self.url,
+            "status": self.status.value,
+            "http_status_code": self.http_status_code,
+            "load_time_ms": self.load_time_ms,
+            "dom_content_loaded_ms": self.dom_content_loaded_ms,
+            "request_count": self.request_count,
+            "page_size_bytes": self.page_size_bytes,
+            "total_errors": self.total_error_count,
+            "console_errors": self.console_error_count,
+            "console_warnings": self.console_warning_count,
+            "http_404_errors": self.http_404_count,
+            "http_4xx_errors": self.http_4xx_count,
+            "http_5xx_errors": self.http_5xx_count,
+            "ignored_count": self.ignored_count,
+            "retry_count": self.retry_count,
+            "errors": [e.to_dict() for e in active_errors],
+            "ignored_errors": [e.to_dict() for e in ignored_errors],
+        }
+
+
+@dataclass
+class ScanSummary:
+    """Gesamtzusammenfassung eines Scans."""
+
+    sitemap_url: str = ""
+    total_urls: int = 0
+    scanned_urls: int = 0
+    urls_with_errors: int = 0
+    total_console_errors: int = 0
+    total_console_warnings: int = 0
+    total_http_404: int = 0
+    total_http_4xx: int = 0
+    total_http_5xx: int = 0
+    total_timeouts: int = 0
+    total_ignored: int = 0
+    scan_duration_ms: int = 0
+
+    @staticmethod
+    def from_results(sitemap_url: str, results: list[ScanResult], duration_ms: int = 0) -> ScanSummary:
+        """Erstellt eine Zusammenfassung aus den Scan-Ergebnissen."""
+        summary = ScanSummary(sitemap_url=sitemap_url)
+        summary.total_urls = len(results)
+        summary.scan_duration_ms = duration_ms
+
+        for result in results:
+            if result.status in (PageStatus.OK, PageStatus.WARNING, PageStatus.ERROR):
+                summary.scanned_urls += 1
+            if result.has_errors:
+                summary.urls_with_errors += 1
+            if result.status == PageStatus.TIMEOUT:
+                summary.total_timeouts += 1
+            summary.total_console_errors += result.console_error_count
+            summary.total_console_warnings += result.console_warning_count
+            summary.total_http_404 += result.http_404_count
+            summary.total_http_4xx += result.http_4xx_count
+            summary.total_http_5xx += result.http_5xx_count
+            summary.total_ignored += result.ignored_count
+
+        return summary
+
+    def to_dict(self) -> dict:
+        """Konvertiert die Zusammenfassung in ein Dictionary."""
+        return {
+            "sitemap_url": self.sitemap_url,
+            "total_urls": self.total_urls,
+            "scanned_urls": self.scanned_urls,
+            "urls_with_errors": self.urls_with_errors,
+            "total_console_errors": self.total_console_errors,
+            "total_console_warnings": self.total_console_warnings,
+            "total_http_404": self.total_http_404,
+            "total_http_4xx": self.total_http_4xx,
+            "total_http_5xx": self.total_http_5xx,
+            "total_timeouts": self.total_timeouts,
+            "total_ignored": self.total_ignored,
+            "scan_duration_ms": self.scan_duration_ms,
+        }
+
+
+def format_page_size(size_bytes: int) -> str:
+    """Formatiert Bytes in lesbare Groesse (KB oder MB).
+
+    Unter 1 MB: "245 KB", ab 1 MB: "1.3 MB".
+
+    Args:
+        size_bytes: Groesse in Bytes.
+
+    Returns:
+        Formatierter String.
+    """
+    if size_bytes <= 0:
+        return "-"
+    kb = size_bytes / 1024
+    if kb < 1:
+        return "< 1 KB"
+    if kb < 1024:
+        return f"{kb:.0f} KB"
+    mb = kb / 1024
+    return f"{mb:.1f} MB"

console_error_scanner/models/settings.py

@@ -0,0 +1,242 @@
+"""Persistierte Einstellungen fuer Console Error Scanner.
+
+Speichert und laedt Benutzereinstellungen aus
+~/.console-error-scanner/settings.json.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from ..i18n import detect_language
+
+logger = logging.getLogger(__name__)
+
+
+# textual-themes 0.5 hat 25 Themes umbenannt (trademark-safety pass).
+# Settings-Files aelterer Versionen koennen alte Slugs gespeichert haben -
+# die werden beim Laden transparent gemappt.
+_LEGACY_THEME_MAP: dict[str, str] = {
+    "c64": "brotkasten",
+    "amiga": "boing",
+    "atari-st": "gemstone",
+    "ibm-terminal": "classic-terminal",
+    "nextstep": "next",
+    "beos": "bebox",
+    "ubuntu": "bunty",
+    "macos": "cupertino",
+    "windows-xp": "luna",
+    "msdos": "commandr",
+    "solaris-cde": "motif",
+    "os2-warp": "warp",
+    "opensuse": "geeko",
+    "linux-mint": "minty",
+    "red-hat": "crimson",
+    "raspberry-pi": "razzy",
+    "freebsd": "beastie",
+    "tudor": "fifty-eight",
+    "goldfinger": "goldfinder",
+    "hulk": "hulkula",
+    "batman": "flughund",
+    "gameboy": "brick",
+    "pan-am": "clipper",
+    "miami-vice": "miami",
+    "martini-racing": "racing",
+    "superman": "metropolis",
+    "spiderman": "spiderized",
+    "gulf-racing": "textual-dark",
+}
+
+
+SETTINGS_DIR = Path.home() / ".console-error-scanner"
+SETTINGS_FILE = SETTINGS_DIR / "settings.json"
+
+# Absturzberichte landen neben den Einstellungen. Angehaengt, nicht ersetzt -
+# so bleibt auch ein frueherer Absturz nachvollziehbar.
+CRASH_LOG_NAME = "last-crash.txt"
+
+
+@dataclass
+class Settings:
+    """Persistierte Benutzereinstellungen.
+
+    Attributes:
+        theme:
+            Name des Textual-Themes.
+        language:
+            UI-Sprache (de/en).
+        accept_consent:
+            Consent-Akzeptierung aktiv.
+        trigger_lazy_load:
+            Seite scrollen fuer Lazy-Loading.
+        concurrency:
+            Parallele Browser-Tabs.
+        timeout:
+            Timeout pro Seite in Sekunden.
+        console_level:
+            Console-Level (error/warn/all).
+        user_agent:
+            Custom User-Agent.
+        cookies:
+            Roh-Cookies-String "name=value; name2=value2".
+        whitelist_path:
+            Pfad zur whitelist.json (leer = keine Whitelist).
+        size_warn_mb:
+            Schwellwert in MB: ueberschreitet die Seitengroesse diesen Wert,
+            wird die URL in der Liste rot hervorgehoben. 0 = aus.
+        score_error_weight:
+            Gewicht der Fehlerquote im Site-Score (in Prozent, 0-100). Das
+            Gewicht der Seitengroesse ist der Rest (100 - score_error_weight).
+    """
+
+    theme: str = "textual-dark"
+    # Erststart: Sprache aus der Systemumgebung, danach aus der Datei.
+    language: str = field(default_factory=lambda: detect_language())
+    accept_consent: bool = True
+    trigger_lazy_load: bool = True
+    respect_robots: bool = True
+    concurrency: int = 8
+    # Aufrufe pro Minute; 0 = ungebremst. Voreingestellt gedrosselt, weil
+    # jede Seite durch einen echten Browser laeuft und entsprechend wiegt.
+    rate_limit_enabled: bool = True
+    rate_per_minute: int = 60
+    timeout: int = 60
+    console_level: str = "warn"
+    user_agent: str = ""
+    cookies: str = ""
+    whitelist_path: str = ""
+    no_headless: bool = False
+    show_preview: bool = False
+    size_warn_mb: int = 10
+    score_error_weight: int = 60
+    proxy_url: str = ""
+    # JIRA-Exportformat: "markdown" (Jira Cloud) oder "wiki" (Server/DC).
+    jira_format: str = "markdown"
+
+    SETTINGS_DIR = SETTINGS_DIR
+    SETTINGS_FILE = SETTINGS_FILE
+
+    def to_dict(self) -> dict:
+        """Konvertiert die Einstellungen in ein Dictionary fuer JSON."""
+        return {
+            "theme": self.theme,
+            "language": self.language,
+            "accept_consent": self.accept_consent,
+            "trigger_lazy_load": self.trigger_lazy_load,
+            "respect_robots": self.respect_robots,
+            "concurrency": self.concurrency,
+            "rate_limit_enabled": self.rate_limit_enabled,
+            "rate_per_minute": self.rate_per_minute,
+            "timeout": self.timeout,
+            "console_level": self.console_level,
+            "user_agent": self.user_agent,
+            "cookies": self.cookies,
+            "whitelist_path": self.whitelist_path,
+            "no_headless": self.no_headless,
+            "show_preview": self.show_preview,
+            "size_warn_mb": self.size_warn_mb,
+            "score_error_weight": self.score_error_weight,
+            "proxy_url": self.proxy_url,
+            "jira_format": self.jira_format,
+        }
+
+    @staticmethod
+    def load() -> Settings:
+        """Laedt die Einstellungen aus der JSON-Datei.
+
+        Gibt Default-Einstellungen zurueck bei Fehler oder fehlender Datei.
+        Migriert dabei alte Theme-Slugs aus textual-themes < 0.5 auf
+        ihre aktuellen Namen und persistiert die Migration.
+        """
+        if not SETTINGS_FILE.is_file():
+            return Settings()
+
+        try:
+            raw = SETTINGS_FILE.read_text(encoding="utf-8")
+            data = json.loads(raw)
+            if not isinstance(data, dict):
+                return Settings()
+            settings = Settings(
+                theme=data.get("theme", "textual-dark"),
+                language=data.get("language", detect_language()),
+                accept_consent=data.get("accept_consent", True),
+                trigger_lazy_load=data.get("trigger_lazy_load", True),
+                respect_robots=data.get("respect_robots", True),
+                concurrency=int(data.get("concurrency", 8)),
+                rate_limit_enabled=bool(data.get("rate_limit_enabled", True)),
+                rate_per_minute=int(data.get("rate_per_minute", 60)),
+                timeout=int(data.get("timeout", 60)),
+                console_level=str(data.get("console_level", "warn")),
+                user_agent=str(data.get("user_agent", "")),
+                cookies=str(data.get("cookies", "")),
+                whitelist_path=str(data.get("whitelist_path", "")),
+                no_headless=bool(data.get("no_headless", False)),
+                show_preview=bool(data.get("show_preview", False)),
+                size_warn_mb=int(data.get("size_warn_mb", 10)),
+                score_error_weight=int(data.get("score_error_weight", 60)),
+                proxy_url=str(data.get("proxy_url", "")),
+                jira_format=("wiki" if str(data.get("jira_format", "markdown")).lower() == "wiki" else "markdown"),
+            )
+        except Exception as exc:
+            logger.warning("Settings konnten nicht geladen werden: %s", exc)
+            return Settings()
+
+        # Legacy-Theme-Slug migrieren
+        if settings.theme in _LEGACY_THEME_MAP:
+            settings.theme = _LEGACY_THEME_MAP[settings.theme]
+            settings.save()
+
+        return settings
+
+    def save(self) -> None:
+        """Speichert die Einstellungen in die JSON-Datei."""
+        try:
+            SETTINGS_DIR.mkdir(parents=True, exist_ok=True)
+            SETTINGS_FILE.write_text(
+                json.dumps(self.to_dict(), indent=2, ensure_ascii=False),
+                encoding="utf-8",
+            )
+        except Exception as exc:
+            logger.warning("Settings konnten nicht gespeichert werden: %s", exc)
+
+
+def parse_cookies(raw: str) -> list[dict[str, str]]:
+    """Parst einen Cookie-String 'name=value; name2=value2' zu einer Liste.
+
+    Args:
+        raw: Cookie-String (Trenner: ';' oder ','; Whitespace tolerant).
+
+    Returns:
+        Liste von {"name": ..., "value": ...}-Dicts. Eintraege ohne '='
+        werden uebersprungen.
+    """
+    if not raw or not raw.strip():
+        return []
+    parts: list[str] = []
+    for chunk in raw.split(";"):
+        parts.extend(p.strip() for p in chunk.split(",") if p.strip())
+    cookies: list[dict[str, str]] = []
+    for entry in parts:
+        if "=" not in entry:
+            continue
+        name, value = entry.split("=", 1)
+        name = name.strip()
+        value = value.strip()
+        if name:
+            cookies.append({"name": name, "value": value})
+    return cookies
+
+
+def cookies_to_string(cookies: list[dict[str, str]]) -> str:
+    """Wandelt eine Cookie-Liste zurueck in den persistierbaren String.
+
+    Args:
+        cookies: Liste von {"name": ..., "value": ...}-Dicts.
+
+    Returns:
+        String der Form 'name=value; name2=value2'.
+    """
+    return "; ".join(f"{c.get('name', '').strip()}={c.get('value', '').strip()}" for c in cookies if c.get("name"))