← Kod źródłowyoptymalizator-jk.py 7520 linii⬇ Pobierz
#!/bin/bash# -*- coding: utf-8 -*-# Ten plik jest jednocześnie skryptem bash i programem w Pythonie:#   bash optymalizator_jk.py    – poniższy fragment sprawdza, czy jest Python 3#                                 (w razie potrzeby go instaluje) i uruchamia program#   python3 optymalizator_jk.py – Python widzi fragment bash jako zwykły napis""":"SKRYPT="$(readlink -f -- "$0")"if ! command -v python3 >/dev/null 2>&1; then    echo "Brak Pythona 3 – instaluję go (potrzebne uprawnienia administratora)."    INSTALACJA="apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y python3"    if [ "$(id -u)" -eq 0 ]; then        sh -c "$INSTALACJA"    elif id -nG | tr ' ' '\n' | grep -qx sudo && command -v sudo >/dev/null 2>&1; then        sudo sh -c "$INSTALACJA"    elif [ -t 0 ]; then        echo "Podaj hasło administratora (konta root):"        su root -c "$INSTALACJA"    else        pkexec sh -c "$INSTALACJA"    fi || { echo "Nie udało się zainstalować Pythona 3."; exit 1; }fiexec python3 "$SKRYPT" "$@"":""""""============================================================================== Optymalizator - Jabłoński KOMPUTERY - www.k.j.pl============================================================================== Konfiguruje Debiana 13 (Trixie) z KDE Plasma „pod klucz”: język polski, Num Lock, hasło tylko przy logowaniu (dla codziennych czynności), pakiet biurowy ArtCraft, przeglądarka Brave, sterowniki grafiki, gry (Steam/Wine/Proton), Docker, Snap/Flatpak w Discover, wygląd (motyw, tapeta, ekran startowy, GRUB), pulpit, menu i zestaw programów. URUCHAMIANIE (jako zwykły użytkownik – bez sudo)   bash optymalizator_jk.py               okno graficzne; brakującego Pythona                                          i PyQt6 program doinstaluje sam   python3 optymalizator_jk.py            to samo   bash optymalizator_jk.py --konsola     tryb tekstowy (np. bez pulpitu)   bash optymalizator_jk.py --symulacja   pokazuje, co by zrobił – nic nie zmienia UPRAWNIENIA   W Debianie 13 konto użytkownika często nie należy do grupy sudo. Wtedy   program raz prosi o hasło konta root (w terminalu przez su, bez terminala   przez pkexec), dodaje konto do grupy sudo, doinstalowuje PyQt6, kopiuje   program do katalogu administratora i zostawia JEDNORAZOWĄ, wygasającą regułę   polkit (tylko to konto, tylko ta kopia, 3 godziny) – dzięki niej okno   uruchamia część administracyjną bez drugiego pytania o hasło. Uruchomienie jako root (np. po   su) otwiera okno na pulpicie zalogowanego użytkownika. BUDOWA PLIKU (wszystko w jednym pliku)   1. Stałe i konfiguracja      – adresy, listy pakietów, typy plików   2. Wykrywanie sprzętu        – działa jako zwykły użytkownik (dla podsumowania)   3. Opis zmian                – jeden tekst dla okna i terminala   4. Narzędzia systemowe       – polecenia, apt, pliki, pliki INI KDE, użytkownicy   5. Kroki                     – każda funkcja krok_*() = jeden punkt listy w oknie   6. Wykonawca                 – uruchamia kroki i raportuje postęp                                  (w trybie okna: linie JSON na stdout)   7. Tryb tekstowy   8. Okno graficzne (PyQt6)    – działa jako użytkownik; część wymagająca                                  uprawnień jest uruchamiana przez pkexec   9. Start i uprawnienia       – su/sudo/pkexec, przygotowanie przed oknem  10. Tryb sesji                – ustawienia każdego konta (pasek zadań, ulubione,                                  ikony, kosz, motyw…) – uruchamiany przy logowaniu  11. main() JAK DODAĆ NOWY KROK   1. Napisz funkcję krok_cos(k: Kontekst) -> str w sekcji 5      (zwracany tekst = krótki opis wyniku; wyjątek Ostrzezenie = wykonano      częściowo, Pominiety = pominięto, każdy inny wyjątek = błąd).   2. Dopisz ją do listy w funkcji lista_krokow() (sekcja 6).   3. Dopisz opis zmiany w zbuduj_opis_zmian() (sekcja 3). Wszystkie zmiany w plikach i wywołania poleceń przechodzą przez funkcje z sekcji 4 (zapisz_plik, uruchom, ...), dzięki czemu tryb --symulacja niczego nie zmienia w systemie. Dziennik działania: /var/log/jablonski-optymalizator.log=============================================================================="""import argparseimport base64import getpassimport globimport grpimport hashlibimport htmlimport importlib.utilimport jsonimport osimport pwdimport secretsimport reimport shleximport shutilimport signalimport socketimport subprocessimport sysimport tempfileimport textwrapimport threadingimport timeimport zipfileimport tracebackimport unicodedataimport urllib.errorimport urllib.parseimport urllib.requestfrom dataclasses import dataclass, fieldfrom typing import Callable, Dict, List, Optional, Tuple# ============================================================================# 1. STAŁE I KONFIGURACJA# ============================================================================WERSJA = "2.0"NAZWA_PROGRAMU = "Optymalizator - Jabłoński KOMPUTERY - www.k.j.pl"USER_AGENT = f"Mozilla/5.0 (X11; Linux) OptymalizatorJK/{WERSJA}"PLIK_DZIENNIKA = "/var/log/jablonski-optymalizator.log"PREFIKS_ZDARZENIA = "@@JK@@"          # linie z tym prefiksem to zdarzenia JSON dla okna# --- Brave ---------------------------------------------------------------BRAVE_KLUCZ_URL = "https://brave-browser-apt-release.s3.brave.com/brave-browser-archive-keyring.gpg"BRAVE_KLUCZ = "/usr/share/keyrings/brave-browser-archive-keyring.gpg"BRAVE_REPO = "https://brave-browser-apt-release.s3.brave.com/"BRAVE_DESKTOP = "brave-browser.desktop"BRAVE_FOLDER_ZAKLADEK = "Jabłoński KOMPUTERY"BRAVE_ZAKLADKI = [    ("Nasza mocna strona", "https://jablonski-komputery.eu/?z=linux"),    ("Kanał YouTube", "https://www.youtube.com/@Jablonski_KOMPUTERY/featured"),    ("Forum wsparcia programu", "https://michal.j.pl/forum/d/47-linux-debian-13-z-kde-jak-ustawi%C4%87-has%C5%82o-tylko-raz-z-num-lock-przy-logowaniu"),    ("Twoje forum wsparcia", "https://michal.j.pl/forum"),]BRAVE_STRONA_STARTOWA = "https://jablonski-komputery.eu/?z=linux&o=wyszukaj"# --- Tapeta --------------------------------------------------------------TAPETA_URL = "https://jablonski-komputery.eu/background.jpg"TAPETA_KATALOG = "/usr/share/wallpapers/JablonskiKOMPUTERY"TAPETA_PLIK = TAPETA_KATALOG + "/contents/images/1920x1080.jpg"TAPETA_NAZWA_U_UZYTKOWNIKA = "Jablonski-KOMPUTERY-tapeta.jpg"# --- Logo, ekran startowy, „O tym systemie” -------------------------------LOGO_URL = "https://jablonski-komputery.eu/logo.png"KATALOG_DANYCH = "/usr/share/jablonski-komputery"LOGO_PLIK = KATALOG_DANYCH + "/logo.png"LOGO_O_SYSTEMIE = KATALOG_DANYCH + "/o-systemie-logo.png"LOGO_START_PLIK = KATALOG_DANYCH + "/logo-start.png"        # logo ekranu startowego (Plymouth)NAPIS_O_SYSTEMIE = "System skonfigurowany i optymalizowany przez\nJabłoński KOMPUTERY"   # \n = nowa liniaSTRONA_O_SYSTEMIE = "https://jablonski-komputery.eu"   # klikany link pod napisemPLYMOUTH_MOTYW = "jablonski"PLYMOUTH_KATALOG = "/usr/share/plymouth/themes/" + PLYMOUTH_MOTYWKOLOR_TLA_STARTU = (0.0, 0.0, 0.0)      # tło ekranu startowego (R, G, B w skali 0–1): czarneKOLOR_TEKSTU_STARTU = (1.0, 1.0, 1.0)   # napisy na ekranie startowym: białeNAPIS_STARTU = "Czekaj..."               # ten sam motyw działa przy starcie i zamykaniu systemuCZCIONKA_STARTU = "Sans 16"# --- Wygląd KDE ---------------------------------------------------------------MOTYW_KDE = "org.kde.breeze.desktop"   # jasny BreezeSCHEMAT_KOLOROW = "BreezeLight"KOLOR_AKCENTU = "#f67400"               # pomarańczowy z palety BreezeKOLOR_AKCENTU_KDE = "246,116,0"# --- Pulpit, pasek zadań, ulubione ------------------------------------------------# Wpisy bez „.desktop” są wyszukiwane po nazwie (np. paczki ArtCraft mają różne nazwy plików)PASEK_ZADAN = ["brave-browser.desktop", "org.kde.dolphin.desktop"]ULUBIONE = ["brave-browser.desktop", "org.kde.kcalc.desktop", "wordcraft", "gridcraft",            "deckcraft", "steam.desktop", "org.kde.discover.desktop", "org.kde.dolphin.desktop"]# --- Ustawienia systemowe KDE ---------------------------------------------------------# Suwak „Szybkość animacji” (Plasma 6): 17 pozycji, wartość v od -4 do 4 co 0,5;# AnimationDurationFactor = 1/2^v, ostatnia pozycja = 0 (natychmiast). 15. pozycja → v=3 → 0,125.SZYBKOSC_ANIMACJI = "0.125"PRZYCIEMNIJ_PO_SEKUNDACH = 15 * 60      # ekran przyciemnia się po 15 min, ale nigdy nie gaśnieSLOWNIK_PISOWNI = "pl_PL"# --- Urządzenia Logitech (pytanie w oknie; wykryte są zaznaczone od razu) ---LOGITECH = {   # id: (nazwa, opis, identyfikatory USB produktu – producent 046d)    "g213": ("Logitech G213 Prodigy", "klawiatura z kolorowym podświetleniem", {"c336"}),    "g102": ("Logitech G102 Lightsync / Prodigy", "mysz z kolorowym podświetleniem",             {"c084", "c092", "c09d"}),    "g19s": ("Logitech G19s / G19", "klawiatura z wyświetlaczem i klawiszami G", {"c228", "c229"}),}PODSWIETLENIE_PLIK = "/var/lib/jablonski-komputery/podswietlenie.json"PODSWIETLENIE_DOMYSLNE = {"kolor": "f67400", "efekt": "staly"}       # pomarańcz J.K.PODSWIETLENIE_EFEKTY = {"staly": "Stały kolor", "oddychanie": "Oddychanie (pulsowanie)",                        "tecza": "Tęcza (zmiana kolorów)"}PODSWIETLENIE_NAZWA = "Podświetlenie Logitech"PODSWIETLENIE_DESKTOP = "/usr/local/share/applications/jablonski-podswietlenie.desktop"USLUGA_PODSWIETLENIA = "jablonski-podswietlenie.service"REGULY_LOGITECH = "/etc/udev/rules.d/70-jablonski-logitech.rules"G19_REPOZYTORIUM = "https://github.com/mortendynamite/g19daemon.git"G19_AUTOSTART = "/etc/xdg/autostart/jablonski-g19daemon.desktop"# --- Launchery gier (Flathub): Lutris (EA, Ubisoft, Rockstar, Battle.net, GOG…) i Heroic (Epic, GOG, Amazon)FLATPAK_GRY = [("net.lutris.Lutris", "Lutris"),               ("com.heroicgameslauncher.hgl", "Heroic Games Launcher")]FLATPAK_GRY_DODATKI = ["org.freedesktop.Platform.VulkanLayer.MangoHud//25.08",                       "org.freedesktop.Platform.VulkanLayer.gamescope//25.08"]# --- Czcionki: Microsoft (core fonts), zamienniki metryczne Office i Libre Barcode 39 ---CZCIONKI_PAKIETY = ["fonts-crosextra-carlito", "fonts-crosextra-caladea",   # zamienniki Calibri, Cambria                    "fonts-liberation", "fonts-liberation2", "fonts-dejavu", "fonts-noto-core",                    "fonts-open-sans", "fonts-roboto", "fonts-ubuntu"]CZCIONKI_MS_KATALOG = "/usr/share/fonts/truetype/msttcorefonts"KOD_KRESKOWY_URL = "https://raw.githubusercontent.com/google/fonts/main/ofl/"KOD_KRESKOWY_PLIKI = ["librebarcode39/LibreBarcode39-Regular.ttf",                      "librebarcode39text/LibreBarcode39Text-Regular.ttf",                      "librebarcode39extended/LibreBarcode39Extended-Regular.ttf",                      "librebarcode39extendedtext/LibreBarcode39ExtendedText-Regular.ttf",                      "librebarcode39/OFL.txt"]KOD_KRESKOWY_KATALOG = "/usr/local/share/fonts/libre-barcode-39"# --- Dodatki (opcje) zainstalowane przez program – żeby przy kolejnym uruchomieniu móc je usunąć ---PLIK_DODATKOW = "/var/lib/jablonski-komputery/dodatki.json"G19_PLIKI = "/var/lib/jablonski-komputery/g19daemon-pliki.txt"DODATKI = {    "czcionki": "Czcionki (Microsoft, zamienniki Office, Libre Barcode 39)",    "multimedia": "MULTIMEDIA – kodeki audio i wideo, Kdenlive, Audacity",    "g213": "Logitech G213 – podświetlenie klawiatury",    "g102": "Logitech G102 – podświetlenie myszy (Piper)",    "g19s": "Logitech G19s – g19daemon",    "gry": "Gry – Steam, Lutris, Heroic, Proton, MangoHud",    "dell": "DELL Unlock Pin ID – pełna wydajność przy nierozpoznanym zasilaczu",    "nvidia_rtx": "nVidia Unlock RTX – szybsze AI (pozycja w menu startowym)",    "antykradziez": "J.K. Anty-Kradzież – zdalna blokada skradzionego komputera",}PLIK_ANTYKRADZIEZY = "/etc/jablonski-komputery/antykradziez.json"   # zgoda klienta na tym komputerze# --- nVidia Unlock RTX: nv-uefi-unlocker (https://github.com/physicsdolphin/nv-uefi-unlocker) ---#     Program UEFI zdejmuje fabryczne ograniczenie rdzeni Tensor w GeForce RTX 20/30/40 (AI: FP16/BF16/TF32).#     Działa przed sterownikiem, do wyłączenia zasilania. Uruchamiany z osobnej pozycji w menu GRUB –#     zwykły start systemu zostaje bez zmian. Pliki muszą leżeć w katalogu głównym partycji EFI.NVUNLOCK_WYDANIE = "https://api.github.com/repos/physicsdolphin/nv-uefi-unlocker/releases/latest"NVUNLOCK_PROJEKT = "https://github.com/physicsdolphin/nv-uefi-unlocker"NVUNLOCK_KATALOG_EFI = "EFI/jablonski-nvunlock"           # na partycji EFINVUNLOCK_PLIKI = "/var/lib/jablonski-komputery/nvunlock-pliki.txt"NVUNLOCK_GRUB = "/etc/grub.d/41_jablonski_nvunlock"NVUNLOCK_GRUB_MENU = "/etc/default/grub.d/91-jablonski-nvunlock.cfg"NVUNLOCK_MODPROBE = "/etc/modprobe.d/jablonski-nvunlock.conf"NVUNLOCK_POZYCJA = "Debian + nVidia Unlock RTX (szybsze AI – na własne ryzyko)"NVUNLOCK_RODZINY = [(r"TU10[246]", "tu10x"), (r"GA10[2-7]", "ga102"), (r"AD10[2-7]", "ad102")]# --- DELL Unlock Pin ID: zasilacz bez rozpoznania (uszkodzona linia ID) → Dell dławi procesor#     sygnałem PROCHOT. Wyłączamy reakcję na zewnętrzny PROCHOT (bit 0 MSR 0x1FC, „BD PROCHOT”).#     Ochrona termiczna samego procesora działa dalej.MSR_POWER_CTL = 0x1FC                  # bit 0: BD PROCHOT (reakcja na zewnętrzny sygnał)MSR_PAKIET_TERM = 0x1B1                # IA32_PACKAGE_THERM_STATUS: bity 2/3 PROCHOT# – stan/logMSR_POWODY_LIMITU = 0x690              # MSR_CORE_PERF_LIMIT_REASONS: bity 0/16 PROCHOT – stan/logUSLUGA_DELL = "jablonski-dell-pin-id.service"HAK_USYPIANIA_DELL = "/usr/lib/systemd/system-sleep/jablonski-dell-pin-id"MODULY_DELL = "/etc/modules-load.d/jablonski-msr.conf"OPCJE_MSR_DELL = "/etc/modprobe.d/jablonski-msr.conf"KODEKI_ZOSTAJA = {"va-driver-all", "vdpau-driver-all", "mesa-va-drivers", "mesa-vdpau-drivers",                  "intel-media-va-driver-non-free"}    # dekodowanie sprzętowe – też dla sterowników# --- Mapy: domyślny program dla adresów geo: (Ustawienia → Domyślne programy → Mapa) ---MAPY_DESKTOP = "/usr/local/share/applications/jablonski-mapy-google.desktop"MAPY_SKRYPT = "/usr/local/bin/jablonski-mapy-google"# --- Aktualizacje (Ustawienia → Aktualizacje): automatycznie, raz w miesiącu ---AKTUALIZACJE_CO_SEKUND = 60 * 60 * 24 * 30          # pozycja „Co miesiąc” w Plasmie 6# --- Sieć: IPv6 wyłączone, DNS Google i Cloudflare ---SERWERY_DNS = ["8.8.8.8", "1.1.1.1"]NM_DNS = "/etc/NetworkManager/conf.d/90-jablonski-dns.conf"NM_IPV6 = "/etc/NetworkManager/conf.d/90-jablonski-ipv6.conf"NM_DISPATCHER_IPV6 = "/etc/NetworkManager/dispatcher.d/90-jablonski-ipv6"SYSCTL_IPV6 = "/etc/sysctl.d/90-jablonski-ipv6.conf"# --- Zapora (ufw): ruch przychodzący zablokowany, z sieci lokalnej dozwolone usługi ---SIECI_LOKALNE = ["192.168.0.0/16", "10.0.0.0/8", "172.16.0.0/12"]BEZ_POLSKICH = str.maketrans("ąćęłńóśźżĄĆĘŁŃÓŚŹŻ–", "acelnoszzACELNOSZZ-")ZAPORA_USLUGI = [            # (opis, porty, protokół)    ("KDE Connect", "1714:1764", "tcp"), ("KDE Connect", "1714:1764", "udp"),    ("RustDesk (połączenie bezpośrednie w LAN)", "21118", "tcp"),    ("RustDesk (wykrywanie w LAN)", "21119", "udp"),    ("Udostępnianie plików Windows (SMB)", "139,445", "tcp"),    ("Udostępnianie plików Windows (NetBIOS)", "137,138", "udp"),    ("NFS", "2049", "tcp"), ("NFS", "2049", "udp"),    ("NFS (rpcbind)", "111", "tcp"), ("NFS (rpcbind)", "111", "udp"),    ("NFS (mountd)", "20048", "tcp"), ("NFS (mountd)", "20048", "udp"),    ("Wykrywanie urządzeń (mDNS/Avahi)", "5353", "udp"),    ("Widoczność w sieci Windows (WS-Discovery)", "3702", "udp"),    ("Widoczność w sieci Windows (WS-Discovery)", "5357", "tcp"),    ("Multimedia w sieci (UPnP/DLNA)", "1900", "udp"),    ("Drukarki (IPP/CUPS)", "631", "tcp"), ("Drukarki (IPP/CUPS)", "631", "udp"),    ("Steam – gra w sieci lokalnej i Remote Play", "27031:27036", "udp"),    ("Steam – przesyłanie gier w LAN", "27036:27037", "tcp"),]KOSZ_DNI = 14                           # pliki starsze są usuwane z koszaKOSZ_PROCENT = 10                       # maks. zajętość dysku przez koszKOSZ_AKCJA = 1                          # po przekroczeniu: 0 ostrzeż, 1 usuń najstarsze, 2 największe# --- Pliki instalowane przez program ------------------------------------------------SKRYPT = os.path.realpath(__file__)SKRYPT_SYSTEMOWY = "/usr/local/lib/jablonski-komputery/optymalizator_jk.py"AUTOSTART_SESJI = "/etc/xdg/autostart/jablonski-komputery-sesja.desktop"AUTOSTART_KOMUNIKATOW = "/etc/xdg/autostart/jablonski-komputery-komunikaty.desktop"USLUGA_START = "jablonski-komputery-start.service"USLUGA_STANU = "jablonski-komputery-stan.service"       # pakiet + tryb „zgubiony” (przed logowaniem)ZEGAR_STANU = "jablonski-komputery-stan.timer"          # …i co 10 minutPLIK_STANU = "/var/lib/jablonski-komputery/stan.json"   # opcje pakietu wg serwera (czytelny dla sesji)CO_ILE_STAN_BEZ_OCHRONY = 6 * 3600                      # bez J.K. Anty-Kradzieży: najwyżej co 6 godzinPLIK_ZGUBIONY = "/var/lib/jablonski-komputery/zgubiony.json"MOTYW_ZGUBIONY = "/usr/share/sddm/themes/jablonski-zgubiony"SDDM_ZGUBIONY = "/etc/sddm.conf.d/zz-jablonski-zgubiony.conf"SSH_ZGUBIONY = "/etc/ssh/sshd_config.d/zz-jablonski-zgubiony.conf"POLECENIE_STARTU = "wget -qO- https://linux.k.j.pl/start.sh | sh"ADRES_PROGRAMU = "https://linux.k.j.pl/optymalizator-jk.py"# Podpis cyfrowy aktualizacji (Ed25519). Każda nowa wersja programu ma obok plik .sig; komputer# uruchamia pobraną wersję tylko wtedy, gdy podpis zgadza się z kluczem publicznym poniżej.# Klucz prywatny jest wyłącznie u Jabłoński KOMPUTERY (nie ma go na serwerze), więc nawet ktoś,# kto przejąłby serwer, nie podsunie komputerom własnego programu. Klucz wpisuje skrypt podpisz.sh.KLUCZ_PODPISU = ""ADRES_PODPISU = ADRES_PROGRAMU + ".sig"# Aktualizacja ustawień po zmianie pakietu – bez pytań: użytkownik klika „Tak”, usługa (root) pobiera# najnowszy program i przeprowadza rekonfigurację z zapamiętanymi wyborami. Reguła polkit pozwala# zalogowanemu użytkownikowi uruchomić tylko tę usługę, bez hasła.USLUGA_AKTUALIZACJI = "jablonski-komputery-aktualizacja@.service"REGULA_AKTUALIZACJI = "/etc/polkit-1/rules.d/50-jablonski-aktualizacja.rules"KATALOG_STANU = "/var/lib/jablonski-komputery"WZORZEC_ZADANIA = re.compile(r"u(\d{1,7})x[0-9a-f]{8}")PLIK_LICENCJI = "/etc/jablonski-komputery/licencja.json"   # kod licencji tego komputeraREGULA_STARTOWA = "/etc/polkit-1/rules.d/10-jablonski-optymalizator-start.rules"# Kopia programu, którą wolno uruchomić dzięki regule startowej: należy do administratora (root),# więc zwykłe konto ani obcy program nie może jej podmienić.SKRYPT_STARTOWY = "/usr/local/lib/jablonski-komputery/start/optymalizator_jk.py"# --- Aktywacja (licencja) -------------------------------------------------AKTYWACJA_URL = "https://linux.k.j.pl/aktywacja.php"WZORZEC_KLUCZA = re.compile(r"[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}")ODPOWIEDZ_OK = "LICENCJA OK"# Opcje włączane w panelu dla każdego klucza (reszta jest w standardzie).# Serwer odsyła je w odpowiedzi na aktywację: „OPCJE: czcionki,gry” (+ „PAKIET: …”).OPCJE_PROGRAMU = ("czcionki", "multimedia", "g213", "g102", "g19s", "gry", "dell", "nvidia_rtx",                  "antykradziez")OPCJE_LOGITECH = ("g213", "g102", "g19s")              # każde urządzenie Logitech osobnoKROKI_OPCJI = {"czcionki": ("czcionki",), "logitech": OPCJE_LOGITECH,               "kodeki": ("multimedia",), "kdenlive": ("multimedia",), "audacity": ("multimedia",),               "steam": ("gry",), "launchery": ("gry",), "dell": ("dell",),               "nvidia_rtx": ("nvidia_rtx",), "antykradziez": ("antykradziez",)}TYTULY_OPCJI = {"czcionki": "Czcionki", "multimedia": "MULTIMEDIA", "gry": "Gry (",                "dell": "DELL Unlock Pin ID", "nvidia_rtx": "nVidia Unlock RTX",                "antykradziez": "J.K. Anty-Kradzież"}def nazwa_pakietu(opcje) -> str:    """Napis na pasku programu (tak samo liczy panel): czcionki = OFFICE, multimedia = MULTIMEDIA,    gry/Logitech = GAMING; dwie lub więcej z tych grup = PROFESSIONAL; bez opcji = STANDARD."""    grupy = [nazwa for nazwa, jest in (        ("OFFICE", "czcionki" in opcje),        ("MULTIMEDIA", "multimedia" in opcje),        ("GAMING", "gry" in opcje or any(o in opcje for o in OPCJE_LOGITECH))) if jest]    return "PROFESSIONAL" if len(grupy) > 1 else (grupy[0] if grupy else "STANDARD")def opcje_z_odpowiedzi(odpowiedz: str) -> List[str]:    """Opcje z odpowiedzi serwera; starszy serwer (bez linii OPCJE) = wszystkie."""    m = re.search(r"^OPCJE:\s*(.*)$", odpowiedz, re.MULTILINE)    if not m:        return list(OPCJE_PROGRAMU)    lista = m.group(1).replace(" ", "").split(",")    if "logitech" in lista and not any(o in lista for o in OPCJE_LOGITECH):        lista += OPCJE_LOGITECH                         # dawna wspólna opcja „logitech”    return [o for o in OPCJE_PROGRAMU if o in lista]# Grafika ustawiana w panelu (adresy PNG): tapeta, logo rozruchowe, logo „O tym systemie”.# Brak adresu = grafika wbudowana (TAPETA_URL, LOGO_URL).GRAFIKA_Z_SERWERA = {"TAPETA": "tapeta", "LOGO_START": "logo_start", "LOGO": "logo"}OSTATNIA_GRAFIKA: Dict[str, str] = {}          # z ostatniej aktywacji licencjidef grafika_z_odpowiedzi(odpowiedz: str) -> Dict[str, str]:    wynik = {}    for linia in odpowiedz.splitlines():        nazwa, _, adres = linia.partition(":")        adres = adres.strip()        if nazwa.strip() in GRAFIKA_Z_SERWERA and re.fullmatch(r"https?://\S{3,500}", adres):            wynik[GRAFIKA_Z_SERWERA[nazwa.strip()]] = adres    return wynik# --- Program „J.K. - Nasza mocna strona” ----------------------------------JK_NAZWA = "J.K. - Nasza mocna strona"JK_URL = "https://jablonski-komputery.eu/?z=linux-app&devid={devid}"PLIK_URZADZENIA = "/etc/jablonski-komputery/urzadzenie"    # odcisk sprzętu (czytelny dla każdego)JK_KATALOG = "/opt/jablonski-komputery"JK_SKRYPT = JK_KATALOG + "/nasza_mocna_strona.py"JK_DESKTOP = "pl.jablonski_komputery.NaszaMocnaStrona.desktop"JK_IKONA = "/usr/share/icons/hicolor/scalable/apps/jablonski-komputery.svg"# --- Docker / NVIDIA / Steam ---------------------------------------------DOCKER_KLUCZ_URL = "https://download.docker.com/linux/debian/gpg"DOCKER_KLUCZ = "/etc/apt/keyrings/docker.asc"NVIDIA_REPO = "https://developer.download.nvidia.com/compute/cuda/repos/{dystr}/{arch}/"HASLO_MOK = "jablonski"               # jednorazowe hasło do zatwierdzenia klucza Secure BootKATALOG_PROTON = "/usr/share/steam/compatibilitytools.d"   # Steam szuka tu narzędzi zgodności# --- Flatpak / Snap --------------------------------------------------------FLATHUB_URL = "https://dl.flathub.org/repo/flathub.flatpakrepo"FLATPAK_WHALER = "com.github.sdv43.whaler"FLATPAK_PROTONUP = "net.davidotek.pupgui2"FLATPAK_PLAYONLINUX = "com.playonlinux.PlayOnLinux4"FLATPAK_NEXTCLOUD = "com.nextcloud.desktopclient.nextcloud"FLATPAK_RUSTDESK = "com.rustdesk.RustDesk"# --- Składniki repozytorium Debiana ---------------------------------------SKLADNIKI_DEBIANA = ["main", "contrib", "non-free", "non-free-firmware"]# --- Typy plików (MIME) ----------------------------------------------------MIME_DOKUMENTY = [    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",   # .docx    "application/vnd.openxmlformats-officedocument.wordprocessingml.template",   # .dotx    "application/vnd.ms-word.document.macroEnabled.12",                           # .docm    "application/msword",                                                         # .doc    "application/vnd.oasis.opendocument.text",                                    # .odt    "application/rtf", "text/rtf",                                                # .rtf]MIME_ARKUSZE = [    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",         # .xlsx    "application/vnd.openxmlformats-officedocument.spreadsheetml.template",      # .xltx    "application/vnd.ms-excel.sheet.macroEnabled.12",                            # .xlsm    "application/vnd.ms-excel",                                                  # .xls    "application/vnd.oasis.opendocument.spreadsheet",                            # .ods    "text/csv",                                                                  # .csv]MIME_PREZENTACJE = [    "application/vnd.openxmlformats-officedocument.presentationml.presentation", # .pptx    "application/vnd.openxmlformats-officedocument.presentationml.slideshow",    # .ppsx    "application/vnd.openxmlformats-officedocument.presentationml.template",     # .potx    "application/vnd.ms-powerpoint",                                             # .ppt    "application/vnd.oasis.opendocument.presentation",                           # .odp]MIME_PDF = ["application/pdf"]MIME_PRZEGLADARKA = [    "text/html", "application/xhtml+xml",    "x-scheme-handler/http", "x-scheme-handler/https",    "x-scheme-handler/about", "x-scheme-handler/unknown",]MIME_DEB = ["application/vnd.debian.binary-package", "application/x-deb"]@dataclassclass AplikacjaArtCraft:    """Jedna aplikacja z rodziny ArtCraft „Crafting Apps” (github.com/storytold)."""    id: str                 # nazwa repozytorium / paczki, np. "wordcraft"    nazwa: str              # nazwa wyświetlana    opis: str               # opis do menu    ikona: str              # ikona z motywu (gdy paczka nie ma własnej)    domyslna: bool          # czy ustawić jako domyślną dla typów MIME    mime: List[str]ARTCRAFT_ORGANIZACJA = "storytold"ARTCRAFT = [    AplikacjaArtCraft("wordcraft", "WordCraft", "Edytor tekstu (dokumenty .docx)",                      "x-office-document", True, MIME_DOKUMENTY),    AplikacjaArtCraft("gridcraft", "GridCraft", "Arkusz kalkulacyjny (.xlsx)",                      "x-office-spreadsheet", True, MIME_ARKUSZE),    AplikacjaArtCraft("deckcraft", "DeckCraft", "Prezentacje (.pptx)",                      "x-office-presentation", True, MIME_PREZENTACJE),    AplikacjaArtCraft("pdfcraft", "PdfCraft", "Przeglądanie i edycja plików PDF",                      "application-pdf", False, MIME_PDF),]# Kodeki audio i wideo (także non-free i „ograniczone patentami”) – z repozytoriów DebianaKODEKI_WYMAGANE = ["gstreamer1.0-plugins-base", "gstreamer1.0-plugins-good", "gstreamer1.0-plugins-bad",                   "gstreamer1.0-plugins-ugly", "gstreamer1.0-libav", "ffmpeg", "libavcodec-extra"]KODEKI_DODATKOWE = [    # GStreamer: pozostałe wtyczki (PipeWire, PulseAudio, sprzętowe dekodowanie, Qt)    "gstreamer1.0-pipewire", "gstreamer1.0-pulseaudio", "gstreamer1.0-alsa", "gstreamer1.0-tools",    "gstreamer1.0-vaapi", "gstreamer1.0-qt6", "gstreamer1.0-x", "gstreamer1.0-gl",    # formaty i narzędzia: MP3, AAC, H.264/H.265, FLAC, Opus, Vorbis, WavPack, Monkey's Audio, MIDI    "lame", "x264", "x265", "faad", "flac", "opus-tools", "vorbis-tools", "wavpack", "mpg123",    "libfdk-aac2", "libdav1d7", "libde265-0", "libheif-plugin-libde265", "libheif-plugin-x265",    "heif-gdk-pixbuf", "heif-thumbnailer", "sox", "libsox-fmt-all", "timidity",    # płyty DVD i Blu-ray    "libdvdnav4", "libdvdread8", "libdvd-pkg", "libbluray2", "libaacs0",    # sprzętowe dekodowanie wideo (VA-API / VDPAU) dla wszystkich kart    "va-driver-all", "vdpau-driver-all", "mesa-va-drivers", "mesa-vdpau-drivers",    "intel-media-va-driver-non-free",    # miniatury filmów i zdjęć w Dolphinie    "ffmpegthumbs", "kdegraphics-thumbnailers", "kimageformat6-plugins", "kimageformat-plugins",]FLATPAK_KODEKI = ["org.freedesktop.Platform.codecs-extra//25.08"]   # kodeki dla programów z Flathuba# Programy instalowane z repozytorium Debiana:# (identyfikator, tytuł, pakiety wymagane, pakiety dodatkowe – instalowane, jeśli istnieją)PROGRAMY_APT = [    ("filezilla", "FileZilla", ["filezilla"], ["filezilla-common"]),    ("gimp", "GIMP", ["gimp"], ["gimp-help-pl", "gimp-data-extras"]),    ("kolourpaint", "KolourPaint", ["kolourpaint"], []),    ("vlc", "VLC", ["vlc"], ["vlc-l10n", "vlc-plugin-access-extra"]),    ("audacity", "Audacity", ["audacity"], []),    ("kdenlive", "Kdenlive", ["kdenlive"], ["frei0r-plugins", "mediainfo"]),    ("juk", "JuK", ["juk"], []),    ("kcalc", "Kalkulator (KCalc)", ["kcalc"], []),    ("gparted", "GParted", ["gparted"], ["exfatprogs", "ntfs-3g", "dosfstools", "mtools"]),    ("synaptic", "Synaptic", ["synaptic"], ["apt-xapian-index"]),]# Pakiety językowe (instalowane bez „polecanych”, żeby nie wróciły LibreOffice/Firefox)PAKIETY_JEZYKOWE = [    "task-polish", "task-polish-desktop", "task-polish-kde-desktop",    "fonts-noto-color-emoji",                  # kolorowe emoji (np. w komunikatach i na stronach)    "hunspell-pl", "aspell-pl", "hyphen-pl", "mythes-pl", "wpolish", "myspell-pl",    "manpages-pl", "manpages-pl-dev",    "qt6-translations-l10n", "qttranslations5-l10n",]# Zbędne programy KDE (pakiet PIM, Konqueror, KMouth)WZORCE_KDE_ZBEDNE = ["kmail", "korganizer", "kontact", "kaddressbook", "ktnef", "akregator",                     "konqueror", "kmouth"]FLATPAK_KDE_ZBEDNE = ["org.kde.kmail2", "org.kde.korganizer", "org.kde.akregator",                      "org.kde.konqueror", "org.kde.kmouth"]# Pakiety biurowe i pocztowe do usunięcia (wzorce dpkg)WZORCE_BIURO = ["libreoffice*", "openoffice*", "libobasis*", "calligra*", "abiword*",                "gnumeric*", "onlyoffice-desktopeditors", "wps-office"]FLATPAK_BIURO = ["org.libreoffice.LibreOffice", "org.onlyoffice.desktopeditors",                 "org.gnome.Gnumeric", "com.abisource.AbiWord", "org.kde.calligra"]SNAP_BIURO = ["libreoffice", "onlyoffice-desktopeditors", "wps-office"]# --- Poczta e-mail: Betterbird (ulepszony Thunderbird) + karteczki XNote++ + rysowanie ---FLATPAK_POCZTA = "eu.betterbird.Betterbird"DESKTOP_POCZTA = "eu.betterbird.Betterbird.desktop"PROFILE_POCZTY = os.path.join(".var", "app", FLATPAK_POCZTA, ".thunderbird")   # w katalogu domowymSTARE_PROFILE_POCZTY = [".thunderbird",                                            # Thunderbird .deb                        os.path.join(".var", "app", "org.mozilla.Thunderbird", ".thunderbird"),                        os.path.join("snap", "thunderbird", "common", ".thunderbird")]XNOTE_ID = "xnote@froihofer.net"        # dodatek XNote++: karteczki z uwagami przy wiadomościachXNOTE_PLIK = "/usr/local/share/jablonski-komputery/xnote.xpi"XNOTE_ADRESY = [    "https://addons.thunderbird.net/thunderbird/downloads/latest/xnotepp/addon-xnotepp-latest.xpi",    "https://addons.thunderbird.net/thunderbird/downloads/latest/xnotepp/latest.xpi",]XNOTE_GITHUB = "https://api.github.com/repos/xnotepp/xnote/releases/latest"ZNACZNIK_XNOTE = ".jablonski-xnote"     # w profilu: dodatek dołożony – nie dokładamy go ponownieUSTAWIENIA_POCZTY = {                   # user.js w profilu poczty    "extensions.autoDisableScopes": 0,              # dołożony dodatek XNote++ od razu włączony    "intl.locale.requested": "pl",    "mail.shell.checkDefaultClient": False,         # bez pytania „czy ustawić jako domyślny”    "spellchecker.dictionary": "pl_PL",}RYSUJ_NAZWA = "Rysuj na wiadomości"RYSUJ_DESKTOP = "/usr/local/share/applications/jablonski-rysuj.desktop"WZORCE_MOZILLA = ["firefox*", "thunderbird*"]FLATPAK_MOZILLA = ["org.mozilla.firefox", "org.mozilla.Thunderbird"]SNAP_MOZILLA = ["firefox", "thunderbird"]# Osierocone biblioteki, które wolno posprzątać po usunięciu powyższych pakietówWZORZEC_SIEROT = re.compile(    r"^(libreoffice|liblibreoffice|libuno|uno-libs|ure|python3-uno|fonts-opensymbol|"    r"libobasis|openoffice|calligra|abiword|libabiword|gnumeric|libgoffice|"    r"firefox|thunderbird|"    r"kdepim|akonadi|libkpim|libkf[56]akonadi|libkf[56]pim|kmail|korganizer|kontact|"    r"kaddressbook|ktnef|akregator|konqueror|libkonq|kmouth|mbox-importer|pim-)")# Pakiety, których usunięcie przy okazji oznaczałoby zepsucie pulpituWZORZEC_KRYTYCZNYCH = re.compile(    r"^(plasma-desktop|plasma-workspace|kde-plasma-desktop|sddm|kwin-.*|dolphin|konsole|"    r"systemd|network-manager|plasma-nm|xserver-xorg-core|apt|dpkg|libc6)(:.*)?$")# Sterownik 550 (Maxwell–Volta) działa pod Wayland bez „explicit sync” (dodane w 555) – w grach# pod XWayland bywa migotanie. True = domyślnie sesja X11 (wybór zostaje na ekranie logowania).SESJA_X11_DLA_550 = True# Klasy kart NVIDIA (przypisanie sterownika – patrz plan_sterownika())NV_NAJNOWSZA = "blackwell+"        # RTX 50xx i nowsze – tylko sterownik 570+ (repozytorium NVIDIA)NV_TURING_ADA = "turing-ada"       # GTX 16xx, RTX 20xx–40xxNV_MAXWELL_VOLTA = "maxwell-volta" # GTX 750/9xx/10xx, Titan V – sterownik 550 z DebianaNV_KEPLER = "kepler"               # GTX 6xx/7xx – sterownik 470 (Debian: nvidia-tesla-470), tylko X11NV_STARA = "starsza"               # Fermi i starsze# ============================================================================# 2. WYKRYWANIE SPRZĘTU (bez uprawnień administratora)# ============================================================================PLIKI_PCI_IDS = ["/usr/share/misc/pci.ids", "/usr/share/hwdata/pci.ids", "/usr/share/pci.ids"]PRODUCENCI_GPU = {"10de": "nvidia", "1002": "amd", "1022": "amd", "8086": "intel"}def czytaj(sciezka: str, domyslnie: str = "") -> str:    """Czyta plik tekstowy; przy błędzie zwraca wartość domyślną."""    try:        with open(sciezka, encoding="utf-8", errors="replace") as f:            return f.read()    except OSError:        return domyslniedef os_release() -> Dict[str, str]:    """Zawartość /etc/os-release jako słownik."""    dane = {}    for linia in czytaj("/etc/os-release").splitlines():        if "=" in linia:            klucz, wartosc = linia.split("=", 1)            dane[klucz.strip()] = wartosc.strip().strip('"')    return danedef architektura() -> str:    """Architektura Debiana: amd64, arm64…"""    try:        return subprocess.run(["dpkg", "--print-architecture"], capture_output=True,                              text=True, timeout=10).stdout.strip() or "amd64"    except (OSError, subprocess.SubprocessError):        return "amd64"def nazwa_z_pci_ids(vendor: str, device: int) -> Optional[str]:    """Szuka nazwy urządzenia w bazie pci.ids (np. 'GM204 [GeForce GTX 970]')."""    szukany_dev = f"{device:04x}"    for plik in PLIKI_PCI_IDS:        if not os.path.exists(plik):            continue        w_producencie = False        with open(plik, encoding="utf-8", errors="replace") as f:            for linia in f:                if not linia.strip() or linia.startswith("#"):                    continue                if not linia.startswith("\t"):                    w_producencie = linia[:4].lower() == vendor                    continue                if w_producencie and not linia.startswith("\t\t"):                    if linia[1:5].lower() == szukany_dev:                        return linia[5:].strip()        return None    return Nonedef moduly_dla_urzadzenia(modalias: str) -> List[str]:    """Moduły jądra pasujące do urządzenia (jak „Kernel modules” w lspci -k)."""    for modprobe in ("/usr/sbin/modprobe", "/sbin/modprobe"):        if os.path.exists(modprobe) and modalias:            try:                wynik = subprocess.run([modprobe, "-R", modalias], capture_output=True,                                       text=True, timeout=10)                return [m.strip() for m in wynik.stdout.split() if m.strip()]            except (OSError, subprocess.SubprocessError):                return []    return []@dataclassclass KartaGraficzna:    slot: str               # np. 0000:01:00.0    vendor: str             # np. 10de    device: int             # identyfikator urządzenia    nazwa: str              # nazwa z pci.ids    moduly: List[str]       # moduły jądra, które obsługują kartę    sterownik: str          # sterownik używany teraz    glowna: bool            # boot_vga = 1 (zwykle karta zintegrowana w laptopie)    @property    def producent(self) -> str:        return PRODUCENCI_GPU.get(self.vendor, "inny")    @property    def krotka_nazwa(self) -> str:        """Nazwa handlowa, np. 'NVIDIA GeForce GTX 970'."""        m = re.search(r"\[([^\]]+)\]", self.nazwa)        nazwa = m.group(1) if m else self.nazwa        przedrostek = {"nvidia": "NVIDIA", "amd": "AMD", "intel": "Intel"}.get(self.producent, "")        return f"{przedrostek} {nazwa}".strip()    @property    def klasa_nvidia(self) -> str:        """Generacja karty NVIDIA – najpierw z kodu układu (GM204, AD102…),        a gdy baza pci.ids nie zna karty (bardzo nowe modele) – z numeru urządzenia."""        m = re.match(r"\s*(GB|GH|GR|AD|GA|TU|GV|GP|GM|GK|GF|GT|G|NV)\d", self.nazwa)        kod = m.group(1) if m else ""        if kod in ("GB", "GH", "GR"):            return NV_NAJNOWSZA        if kod in ("AD", "GA", "TU"):            return NV_TURING_ADA        if kod in ("GV", "GP", "GM"):            return NV_MAXWELL_VOLTA        if kod == "GK":            return NV_KEPLER        if kod in ("GF", "GT", "G", "NV"):            return NV_STARA        # Brak kodu układu – przybliżenie po identyfikatorze urządzenia        if self.device >= 0x2B00:            return NV_NAJNOWSZA        if self.device >= 0x1E00:            return NV_TURING_ADA        if self.device >= 0x1340:            return NV_MAXWELL_VOLTA        if self.device >= 0x0FC0:            return NV_KEPLER        return NV_STARA    @property    def klasa_amd(self) -> str:        """amdgpu – nowoczesna karta; si_cik – GCN 1/2 (HD 7000–R9 200, obsługiwana        przez radeon i amdgpu); radeon – starsze karty TeraScale."""        if "amdgpu" in self.moduly and "radeon" in self.moduly:            return "si_cik"        if "amdgpu" in self.moduly or self.sterownik == "amdgpu":            return "amdgpu"        if "radeon" in self.moduly or self.sterownik == "radeon":            return "radeon"        return "amdgpu"def wykryj_karty_graficzne() -> List[KartaGraficzna]:    """Wszystkie karty graficzne z /sys (klasa PCI 0x03xxxx)."""    karty = []    for katalog in sorted(glob.glob("/sys/bus/pci/devices/*")):        if not czytaj(os.path.join(katalog, "class")).strip().startswith("0x03"):            continue        vendor = czytaj(os.path.join(katalog, "vendor")).strip().lower().replace("0x", "")        try:            device = int(czytaj(os.path.join(katalog, "device")).strip(), 16)        except ValueError:            device = 0        nazwa = nazwa_z_pci_ids(vendor, device) or f"[nowy model {vendor}:{device:04x}]"        sciezka_sterownika = os.path.join(katalog, "driver")        sterownik = (os.path.basename(os.readlink(sciezka_sterownika))                     if os.path.islink(sciezka_sterownika) else "")        karty.append(KartaGraficzna(            slot=os.path.basename(katalog), vendor=vendor, device=device, nazwa=nazwa,            moduly=moduly_dla_urzadzenia(czytaj(os.path.join(katalog, "modalias")).strip()),            sterownik=sterownik,            glowna=czytaj(os.path.join(katalog, "boot_vga")).strip() == "1"))    return kartydef czy_laptop() -> bool:    """Laptop = typ obudowy z DMI (8–14, 30–32…) albo obecność baterii."""    try:        typ = int(czytaj("/sys/class/dmi/id/chassis_type", "0").strip() or 0)    except ValueError:        typ = 0    if typ in {8, 9, 10, 11, 12, 14, 18, 21, 30, 31, 32}:        return True    return any(czytaj(p).strip() == "Battery" for p in glob.glob("/sys/class/power_supply/*/type"))POLSKIE_LITERY = str.maketrans("ąćęłńóśźżĄĆĘŁŃÓŚŹŻ", "acelnoszzACELNOSZZ")def nazwa_hosta(nazwa: str) -> str:    """Nazwa sieciowa (hostname) z dowolnej nazwy: „Biuro Łódź 2” → „biuro-lodz-2”.    Dozwolone są tylko małe litery a–z, cyfry i myślniki, maksymalnie 63 znaki."""    s = unicodedata.normalize("NFKD", nazwa.strip().translate(POLSKIE_LITERY))    s = s.encode("ascii", "ignore").decode().lower()    s = re.sub(r"[^a-z0-9-]+", "-", s)    s = re.sub(r"-{2,}", "-", s).strip("-")    return s[:63].strip("-")def obecna_nazwa_komputera() -> str:    """Ładna nazwa (PRETTY_HOSTNAME z /etc/machine-info) albo nazwa sieciowa."""    m = re.search(r'^PRETTY_HOSTNAME="?([^"\n]*)"?', czytaj("/etc/machine-info"), re.M)    return (m.group(1).strip() if m else "") or socket.gethostname()def normalizuj_klucz(tekst: str) -> str:    """„a4vc 7gw1-kjdc” → „A4VC-7GW1-KJDC”; zwraca '' gdy to nie jest 12 liter/cyfr."""    znaki = re.sub(r"[^A-Za-z0-9]", "", tekst or "").upper()    return f"{znaki[:4]}-{znaki[4:8]}-{znaki[8:]}" if len(znaki) == 12 else ""def zapytaj_serwer_licencji(parametry: Dict[str, str], czas: float = 15) -> str:    """GET do aktywacja.php; zwraca odpowiedź serwera (tekst, bez spacji na brzegach)."""    url = AKTYWACJA_URL + "?" + urllib.parse.urlencode(parametry)    zadanie = urllib.request.Request(url, headers={"User-Agent": USER_AGENT})    with urllib.request.urlopen(zadanie, timeout=czas) as odp:        return odp.read(4096).decode("utf-8", "replace").strip()def _wynik_polecenia(polecenie: List[str]) -> str:    try:        return subprocess.run(polecenie, capture_output=True, text=True, timeout=10).stdout    except (OSError, subprocess.SubprocessError):        return ""def _dysk_systemowy() -> List[str]:    """Numery seryjne fizycznych dysków, na których leży system („/”) – także spod LVM/LUKS."""    zrodlo = re.sub(r"\[.*\]$", "", _wynik_polecenia(["findmnt", "-no", "SOURCE", "/"]).strip())    if not zrodlo:        return []    numery = []    for linia in _wynik_polecenia(["lsblk", "-sPno", "TYPE,TRAN,SERIAL", zrodlo]).splitlines():        pola = dict(re.findall(r'(\w+)="([^"]*)"', linia))        if pola.get("TYPE") == "disk" and pola.get("SERIAL") and pola.get("TRAN") != "usb":            numery.append(pola["SERIAL"].strip())    return sorted(set(numery))def _adresy_mac_wbudowane() -> List[str]:    """Fabryczne adresy MAC wbudowanych kart przewodowych (bez USB, Wi-Fi i wirtualnych –    Wi-Fi potrafi losować adres, więc identyfikator byłby niestały)."""    adresy = []    for katalog in sorted(glob.glob("/sys/class/net/*")):        urzadzenie = os.path.join(katalog, "device")        if (not os.path.exists(urzadzenie) or os.path.exists(os.path.join(katalog, "wireless"))                or "/usb" in os.path.realpath(urzadzenie)):            continue        nazwa = os.path.basename(katalog)        m = re.search(r"permaddr ([0-9a-f:]{17})", _wynik_polecenia(["ip", "-o", "link", "show", "dev", nazwa]))        adres = m.group(1) if m else czytaj(os.path.join(katalog, "address")).strip()        if adres and adres != "00:00:00:00:00:00":            adresy.append(adres.lower())    return sorted(set(adresy))def identyfikator_sprzetu() -> Tuple[str, str]:    """(identyfikator, opis) komputera, np. ("3F9A-07C2-B1D4-8E66", "FUJITSU FUTRO S740").    Procesory x86 nie mają odczytywalnego numeru seryjnego, a numery płyty głównej są    w Linuksie dostępne tylko dla roota – aktywacja działa jeszcze bez uprawnień.    Dlatego identyfikator to skrót SHA-256 z danych dostępnych dla każdego:    producent i model komputera oraz płyty, numer seryjny dysku systemowego i fabryczny    adres MAC wbudowanej karty sieciowej. Zmieni się po wymianie dysku systemowego lub    płyty głównej – wtedy w panelu licencji wystarczy „zwolnić” stary komputer."""    def dmi(pole: str) -> str:        wartosc = czytaj(f"/sys/class/dmi/id/{pole}").strip()        puste = ("", "to be filled by o.e.m.", "system product name", "default string", "none")        return "" if wartosc.lower() in puste else wartosc    skladniki = ["dmi:" + "|".join(dmi(p) for p in ("sys_vendor", "product_name",                                                     "board_vendor", "board_name"))]    skladniki += ["dysk:" + s for s in _dysk_systemowy()]    skladniki += ["mac:" + a for a in _adresy_mac_wbudowane()]    if len(skladniki) == 1:                          # brak dysku i karty – ostatnia deska ratunku        skladniki.append("machine-id:" + czytaj("/etc/machine-id").strip())    skrot = hashlib.sha256("\n".join(skladniki).encode()).hexdigest().upper()[:16]    identyfikator = "-".join(skrot[i:i + 4] for i in range(0, 16, 4))    opis = " ".join(x for x in (dmi("sys_vendor"), dmi("product_name")) if x) or "nieznany model"    return identyfikator, opis[:100]def licencja_dla_komputera(nazwa: str) -> Optional[str]:    """?czy-jest-licencja=NAZWA → klucz przypisany do komputera albo None.    Wysyłamy też identyfikator sprzętu: serwer nie poda klucza, który jest już zajęty    przez inny komputer (np. gdy ktoś zgadł nazwę)."""    sprzet, _ = identyfikator_sprzetu()    m = WZORZEC_KLUCZA.search(zapytaj_serwer_licencji({"czy-jest-licencja": nazwa,                                                       "sprzet": sprzet}))    return m.group(0) if m else Nonedef aktywuj_licencje(klucz: str, nazwa: str) -> Tuple[bool, str, List[str]]:    """?klucz-id=KLUCZ → (czy_poprawny, komunikat dla użytkownika).    Dodatkowo wysyłamy nazwę komputera, identyfikator i opis sprzętu oraz wersję programu.    Serwer zapisuje komputer przy kluczu (limit komputerów liczy identyfikatory sprzętu)    i przypisuje klucz do nazwy (przy kolejnej instalacji podpowie się sam)."""    sprzet, opis = identyfikator_sprzetu()    try:        odpowiedz = zapytaj_serwer_licencji({"klucz-id": klucz, "host": nazwa, "sprzet": sprzet,                                             "sprzet-opis": opis, "wersja": WERSJA})    except (urllib.error.URLError, OSError) as e:        return False, f"Nie udało się połączyć z serwerem licencji ({e}). Sprawdź internet.", []    if ODPOWIEDZ_OK in odpowiedz:        opcje = opcje_z_odpowiedzi(odpowiedz)        OSTATNIA_GRAFIKA.clear()        OSTATNIA_GRAFIKA.update(grafika_z_odpowiedzi(odpowiedz))        return True, f"Licencja aktywna – pakiet {nazwa_pakietu(opcje)}.", opcje    if "LIMIT" in odpowiedz.upper():        return False, ("Ten kod jest już wykorzystany na innym komputerze (limit komputerów). "                       f"Identyfikator tego komputera: {sprzet}"), []    return False, "Kod aktywacyjny jest nieprawidłowy.", []def internet_dziala(host: str = "deb.debian.org", port: int = 443, czas: float = 4) -> bool:    try:        with socket.create_connection((host, port), timeout=czas):            return True    except OSError:        return Falsedef jest_kde() -> bool:    """Czy zainstalowany jest pulpit KDE Plasma (powłoka plasmashell)."""    return bool(shutil.which("plasmashell") or os.path.exists("/usr/bin/plasmashell"))def jest_debian13(system: Optional[Dict[str, str]] = None) -> bool:    system = system if system is not None else os_release()    return system.get("ID") == "debian" and system.get("VERSION_ID") == "13"def nazwa_systemu() -> str:    return os_release().get("PRETTY_NAME", "nieznany system")TEKST_BRAK_KDE = ("Ten program działa wyłącznie na Debianie 13 z pulpitem KDE Plasma. "                  "Nie wykryto KDE Plasma – Optymalizator konfiguruje właśnie ten pulpit, "                  "więc nie można go tu użyć. Zainstaluj Debiana 13 z pulpitem KDE Plasma.")TEKST_RYZYKO = ("Optymalizator jest przygotowany i sprawdzony wyłącznie dla Debiana 13 (Trixie) "                "z KDE Plasma. Na innym systemie może go USZKODZIĆ – np. zmienić repozytoria "                "pakietów, usunąć potrzebne programy albo zainstalować niepasujące sterowniki – "                "i komputer może przestać się poprawnie uruchamiać.")@dataclassclass Sprzet:    karty: List[KartaGraficzna]    laptop: bool    system: Dict[str, str]    internet: bool    host: str    kde: bool = True    @property    def hybryda(self) -> bool:        """Dwie (lub więcej) karty graficzne – typowo laptop z grafiką zintegrowaną i dedykowaną."""        return len(self.karty) >= 2    @property    def debian13(self) -> bool:        return jest_debian13(self.system)    def ma(self, producent: str) -> bool:        return any(k.producent == producent for k in self.karty)def wykryj_sprzet(sprawdz_internet: bool = True) -> Sprzet:    return Sprzet(karty=wykryj_karty_graficzne(), laptop=czy_laptop(), system=os_release(),                  internet=internet_dziala() if sprawdz_internet else True,                  host=socket.gethostname(), kde=jest_kde())def plan_sterownika(karta: KartaGraficzna) -> str:    """Opis tego, co zostanie zainstalowane dla danej karty (do podsumowania)."""    if karta.producent == "nvidia":        return {            NV_NAJNOWSZA: "najnowszy sterownik NVIDIA z oficjalnego repozytorium NVIDIA dla "                          "Debiana 13 (moduły otwarte) – sterownik 550 z Debiana nie obsługuje "                          "kart RTX 50 i nowszych",            NV_TURING_ADA: "najnowszy sterownik NVIDIA z oficjalnego repozytorium NVIDIA "                           "(moduły otwarte, lepsza praca pod Wayland i w grach); gdy repozytorium "                           "będzie niedostępne – sterownik 550 z Debiana",            NV_MAXWELL_VOLTA: "zamknięty sterownik NVIDIA 550 z repozytorium Debiana (obsługuje "                              "tę kartę; repozytorium NVIDIA dla Debiana 13 ma już tylko nowsze "                              "sterowniki bez jej obsługi)" +                              ("; domyślna sesja pulpitu X11 – z tym sterownikiem najstabilniejsza"                               " w grach" if SESJA_X11_DLA_550 else ""),            NV_KEPLER: "zamknięty sterownik NVIDIA 470 z repozytorium Debiana (ostatni dla tej "                       "karty), z wstrzymanymi aktualizacjami (apt-mark hold); domyślna sesja "                       "pulpitu X11 – Wayland z tym sterownikiem nie działa",            NV_STARA: "karta zbyt stara dla sterowników NVIDIA – zostanie otwarty sterownik "                      "nouveau",        }[karta.klasa_nvidia]    if karta.producent == "amd":        return {            "amdgpu": "sterownik amdgpu + Mesa (OpenGL, Vulkan, dekodowanie wideo) i firmware AMD",            "si_cik": "przełączenie z „radeon” na nowszy „amdgpu” (karta GCN 1/2) – działa Vulkan, "                      "a więc DXVK i Proton; do tego Mesa i firmware AMD",            "radeon": "sterownik radeon + Mesa i firmware AMD (starsza karta bez obsługi Vulkan)",        }[karta.klasa_amd]    if karta.producent == "intel":        return "sterownik Mesa + sprzętowe dekodowanie wideo Intel (VA-API) i firmware"    return "sterownik wbudowany w system (np. maszyna wirtualna) – bez zmian"# ============================================================================# 3. OPIS ZMIAN (wyświetlany przed rozpoczęciem)# ============================================================================def zbuduj_opis_zmian(sprzet: Sprzet, nazwa: Optional[str] = None, opcje=OPCJE_PROGRAMU                      ) -> Tuple[List[str], List[Tuple[str, List[str]]]]:    """Zwraca (ostrzeżenia, sekcje). Sekcja = (tytuł, lista punktów).    Punkt zaczynający się od „!” jest wyróżniany jako uwaga."""    nazwa = nazwa or obecna_nazwa_komputera()    host = nazwa_hosta(nazwa) or sprzet.host    ostrzezenia = []    if not sprzet.kde:        ostrzezenia.append("Nie wykryto pulpitu KDE Plasma.")    if not sprzet.debian13:        ostrzezenia.append(            f"Program jest przygotowany dla Debiana 13, a wykryto: "            f"{sprzet.system.get('PRETTY_NAME', 'nieznany system')}.")    if not sprzet.internet:        ostrzezenia.append("Brak połączenia z internetem – jest ono niezbędne do instalacji.")    grafika = []    if sprzet.karty:        for karta in sprzet.karty:            grafika.append(f"{karta.krotka_nazwa}: {plan_sterownika(karta)}.")        if sprzet.hybryda:            tekst = ("Dwie karty graficzne" + (" w laptopie" if sprzet.laptop else "") +                     ": switcheroo-control (w menu programu: „Uruchom na dedykowanej karcie "                     "graficznej”)")            if sprzet.ma("nvidia"):                tekst += (", polecenie prime-run do gier na karcie NVIDIA i usypianie karty "                          "NVIDIA, gdy nie jest używana (oszczędza baterię)")            grafika.append(tekst + ".")    else:        grafika.append("Nie wykryto karty graficznej – ten krok zostanie pominięty.")    repozytoria = "Brave, Docker, Flathub, Snap Store"    if any(k.producent == "nvidia" and k.klasa_nvidia in (NV_NAJNOWSZA, NV_TURING_ADA)           for k in sprzet.karty):        repozytoria = "NVIDIA, " + repozytoria    zakladki = ", ".join(f"„{n}” ({u})" for n, u in BRAVE_ZAKLADKI)    sekcje = [        ("Nazwa komputera", [            f"„{nazwa}” (nazwa w sieci: {host}) – także w KDE Connect i Bluetooth.",        ]),        ("Repozytoria systemowe", [            "Włączenie składników contrib, non-free i non-free-firmware oraz architektury i386 "            "(potrzebna m.in. dla Wine). Wyłączenie źródła „płyta instalacyjna”.",            f"Dodanie repozytoriów: {repozytoria}.",        ]),        ("Język polski", [            "Język i formaty systemu: polski (pl_PL.UTF-8); polski układ klawiatury, jeśli "            "ustawiony był amerykański.",            "Kompletne pakiety językowe: tłumaczenia KDE/Qt, słowniki pisowni, dzielenie "            "wyrazów, synonimy, polskie strony podręcznika; programy Flatpak także po polsku.",        ]),        ("Klawiatura numeryczna (Num Lock)", [            "Laptop: program zapyta, czy ma klawiaturę numeryczną. TAK – Num Lock włączy się już "            "na ekranie logowania; NIE – zostanie wyłączony (na laptopach bez bloku numerycznego "            "włączony Num Lock zamienia część liter w cyfry).",        ] if sprzet.laptop else [            "Num Lock włączony od razu – już na ekranie logowania, po zalogowaniu i w konsolach "            "tekstowych (komputer stacjonarny – bez pytania).",        ]),        ("Hasło tylko raz – przy logowaniu", [            "Hasło wpisujesz przy włączaniu komputera – i to wszystko. Jak w Windows z Kontrolą konta "            "użytkownika ustawioną na „Nigdy nie powiadamiaj”: instalowanie programów (w Discover "            "i z pobranych plików .deb), aktualizacje, Ustawienia systemowe, konta, pendrive'y, "            "dyski, Wi-Fi, drukarki, czcionki, GParted, Synaptic – bez okienek z hasłem.",            "Bezpiecznie: działa tylko dla osoby siedzącej przy komputerze. Przez internet (SSH), "            "z programów działających w tle i z innych kont nikt z tego nie skorzysta.",            "W terminalu (czarne okno z poleceniami) sudo zapyta o hasło, a potem przez pół godziny "            "już nie – przy wpisywaniu zobaczysz gwiazdki.",            "Wszystkie obecne konta stają się administratorami (grupa sudo).",            "Blokada ekranu: automatycznie nigdy, ale po wybudzeniu komputera – tak (wtedy trzeba "            "wpisać hasło). Wyłączony portfel KWallet.",        ]),        ("Zasilanie", [            f"Ekran przyciemni się po {PRZYCIEMNIJ_PO_SEKUNDACH // 60} minutach bezczynności, ale nigdy "            "się nie wyłączy; bezczynność nie wstrzymuje posiedzenia.",            "Profil zasilania: wysoka wydajność (jeśli komputer ją obsługuje); KDE nie przełącza "            "go samo na oszczędzanie energii – także przy słabej baterii.",            "Wyłączone usypianie i hibernacja – także po bezczynności, z menu i po zamknięciu "            "klapy laptopa.",        ]),        ("Ustawienia KDE", [            "Szybkość animacji: prawie najszybsza (15. pozycja suwaka z 17).",            "Wyłączanie i wylogowanie bez pytania „Czy na pewno?”; po zalogowaniu pusty pulpit "            "(bez przywracania programów z poprzedniej sesji).",            "Sprawdzanie pisowni włączone – słownik polski.",            "Informacja zwrotna dla KDE (telemetria): wyłączona.",            "Blokada ekranu: nigdy (z zaznaczonym „Blokuj po wybudzeniu”).",            "Domyślny program do map: Mapy Google (w przeglądarce).",            "Dolphin: po uruchomieniu katalog domowy, widok zapamiętywany osobno dla każdego katalogu, "            "archiwa otwierane jak katalogi, przenoszenie do kosza i usuwanie bez pytania o potwierdzenie.",            "Skróty klawiszowe jak w Windows: Ctrl+Shift+Esc i Ctrl+Alt+Del – Menedżer zadań (Monitor "            "systemu), Win+Shift+S – wycinek ekranu, Win+R – okienko „Uruchom”, Win+I – Ustawienia, "            "Win+E – pliki. Działają też: Win+L (blokada), Win+D (pulpit), Win+V (historia schowka), "            "Win+. (emoji), Win+strzałki (okno do krawędzi), Alt+Tab, Alt+F4, Print Screen.",        ]),        ("Urządzenia Logitech (te, które są w Twoim pakiecie)", [            f"G213 Prodigy i G102 Lightsync: program „{PODSWIETLENIE_NAZWA}” do wyboru koloru i "            "efektu klawiatury i myszki; kolor ustawia się sam przy starcie komputera – jeszcze "            "przed ekranem logowania (g810-led, libratbag/Piper).",            "G19s: obsługa klawiszy G/M i wyświetlacza (g19daemon) – uruchamia się po zalogowaniu.",        ]),        ("Aktualizacje", [            "Od razu: aktualizacja całego systemu i programów Flatpak do najnowszych wersji.",            "Później: Discover sam instaluje aktualizacje, sprawdzając je raz w miesiącu.",        ]),        ("Sieć i zapora", [            "IPv6 wyłączone w sieciach przewodowych i Wi-Fi (także w nowych sieciach).",            "Serwery DNS: " + " i ".join(SERWERY_DNS) + " (Google i Cloudflare) – dla każdej sieci.",            "Zapora sieciowa (ufw) włączona: z internetu nic nie wejdzie do komputera; z sieci "            "lokalnej działają KDE Connect, RustDesk, udostępnianie plików (SMB, NFS), "            "drukarki i wykrywanie urządzeń. Ustawienia: Ustawienia systemowe → Zapora.",        ]),        ("Pulpit i menu", [            "Ikony na Pulpicie: „Ten komputer” (otwiera Dolphin w katalogu domowym), Kosz "            f"i „{JK_NAZWA}”.",            f"Kosz sam usuwa pliki starsze niż {KOSZ_DNI} dni, a gdy zajmie {KOSZ_PROCENT}% dysku "            "– usuwa najpierw najstarsze.",            "Pasek zadań: przypięte tylko Brave i Dolphin.",            "Ulubione w menu: Brave, Kalkulator, WordCraft, GridCraft, DeckCraft, "            + ("Steam, " if "gry" in opcje else "") + "Discover i Dolphin.",        ]),        ("Kontakt z Jabłoński KOMPUTERY – co i po co wysyła komputer", [            "Każda wiadomość do nas ma jeden cel: żeby Twój komputer działał dobrze i żebyśmy mogli "            "Ci pomóc. Nie wysyłamy plików, zdjęć, haseł, historii przeglądania, zrzutów ekranu, "            "nazw kont ani listy programów.",            "Przy włączeniu: kod aktywacyjny, „odcisk” sprzętu (skrót – nie da się z niego odczytać "            "numerów seryjnych), model i nazwa komputera. Po co: Twoja licencja działa tylko na Twoim "            "komputerze, więc nikt inny nie wykorzysta Twojego kodu, a my od razu wiemy, z którym "            "komputerem rozmawiamy, gdy dzwonisz po pomoc.",            "Numer ID RustDesk. Po co: żeby pomoc zdalna ruszyła w minutę, bez dyktowania numerów. "            "To jak numer telefonu – połączenie i tak wymaga Twojej zgody albo hasła z Twojego ekranu.",            "Po zalogowaniu: pytanie o wiadomości od nas (godzina, bez nazwy konta) i informacja, że "            "kliknięto OK. Po co: ważne ostrzeżenia i porady trafią do Ciebie na pewno, a my nie "            "wyślemy tej samej wiadomości dwa razy. Wiadomości to tylko tekst na ekranie.",            "Sprawdzanie Twojego pakietu: przy włączeniu i najwyżej co 6 godzin (z J.K. "            "Anty-Kradzieżą co 10 minut). Po co: nowe opcje i poprawki dostajesz sam(a), bez "            "proszenia, a skradziony komputer zablokuje się szybko. Program pobierany przy "            "aktualizacji jest podpisany cyfrowo – komputer sprawdza podpis, zanim go uruchomi.",            "„J.K. – Nasza mocna strona” otwiera naszą stronę z „odciskiem” komputera. Po co: "            "zobaczysz informacje o swoim komputerze i pakiecie bez zakładania konta i logowania.",            "Przy każdym połączeniu serwer widzi adres IP – jak każda strona internetowa. Po co: "            "chroni Twój kod przed zgadywaniem (limit prób), pomaga wyjaśnić problem z aktywacją, "            "a gdy zgłosisz kradzież – pokazuje, skąd odezwał się zgubiony komputer.",        ]),        ("Wygląd", [            "Jasny motyw Breeze z pomarańczowym kolorem zaznaczenia.",            f"Tapeta z {TAPETA_URL} (zapisana w katalogu Obrazy) – na pulpicie i na ekranie "            "logowania.",            f"Ekran startowy: zamiast przewijającego się tekstu logo z {LOGO_URL} na środku "            f"czarnego ekranu, a pod nim biały napis „{NAPIS_STARTU}”.",            "GRUB bez menu wyboru – system startuje od razu (gdy na dysku nie ma innych "            "systemów; menu można wywołać klawiszem Esc).",            f"„O tym systemie” (Ośrodek informacji): logo J.K. pod logo Debiana, napis "            f"„{NAPIS_O_SYSTEMIE.replace(chr(10), ' / ')}” (w dwóch liniach), a niżej klikany "            f"link {STRONA_O_SYSTEMIE}.",        ]),        ("Czcionki", [            "Czcionki Microsoft: Arial, Times New Roman, Courier New, Verdana, Georgia, Tahoma "            "(z Wine), Trebuchet MS, Comic Sans MS, Impact, Webdings i inne.",            "Zamienniki czcionek Office o identycznych wymiarach: Carlito zamiast Calibri, Caladea "            "zamiast Cambria, Liberation zamiast Arial/Times/Courier – dokumenty z Worda nie "            "„rozjeżdżają się”.",            "Libre Barcode 39 (zwykła, Text, Extended, Extended Text) – kody kreskowe Code 39 "            "w dokumentach i arkuszach.",            "Dodatkowo: Noto, Open Sans, Roboto, Ubuntu, DejaVu i kolorowe emoji.",        ]),        ("Pakiet biurowy", [            "Usunięcie: LibreOffice, OpenOffice, Calligra, AbiWord, Gnumeric, ONLYOFFICE, "            "WPS Office (paczki .deb, Flatpak i Snap).",            "Instalacja ArtCraft WordCraft, GridCraft i DeckCraft jako domyślnych programów dla "            "plików .docx/.doc/.odt/.rtf, .xlsx/.xls/.ods/.csv oraz .pptx/.ppt/.odp.",            "Instalacja ArtCraft PdfCraft (pliki PDF).",            "!Programy ArtCraft są we wczesnej fazie rozwoju (pre-alfa) – mogą nie mieć polskiego "            "tłumaczenia i nie wszystkie dokumenty otworzą się poprawnie.",        ]),        ("Usuwane programy KDE", [            "KMail, KOrganizer, Kontact, KAddressBook, KTnef, Akregator, Konqueror i KMouth "            "(razem z nieużywanymi już bibliotekami Akonadi).",        ]),        ("Internet i poczta", [            "Usunięcie Firefox i Thunderbird.",            "Program pocztowy Betterbird (ulepszony Thunderbird, Flatpak) jako domyślny – po polsku, "            "z obsługą Gmaila, Microsoft 365/Exchange i zwykłych skrzynek; konta i poczta z "            "Thunderbirda zostaną przeniesione.",            "Karteczki z uwagami przy wiadomościach (dodatek XNote++).",            f"„{RYSUJ_NAZWA}” w menu: zaznaczasz fragment wiadomości, rysujesz pisakiem, "            "zakreślaczem, strzałkami i tekstem, a potem wklejasz go do odpowiedzi.",            "Instalacja przeglądarki Brave (oficjalne repozytorium) jako domyślnej.",            f"Folder zakładek „{BRAVE_FOLDER_ZAKLADEK}”: {zakladki}.",            f"Strona startowa i strona główna: {BRAVE_STRONA_STARTOWA}",        ]),        (JK_NAZWA, [            f"Program „{JK_NAZWA}” dla wszystkich użytkowników – skrót na Pulpicie i w menu.",            "Otwiera w okienku stronę klienta: " + JK_URL.format(devid="[odcisk sprzętu]")            + " – konto i dane przygotowane dla tego komputera.",        ]),        ("Programy", [            "Nextcloud (klient plików), RustDesk, FileZilla, GIMP, KolourPaint, VLC, "            "JuK, Kalkulator (KCalc), GParted, Synaptic.",        ]),        ("MULTIMEDIA – kodeki audio i wideo, Kdenlive, Audacity", [            "Kdenlive – montaż filmów.",            "Audacity – nagrywanie i obróbka dźwięku.",            "Wszystkie kodeki z repozytoriów Debiana, także non-free: MP3, AAC (w tym FDK-AAC), "            "H.264, H.265/HEVC, AV1, VP8/VP9, FLAC, Opus, Vorbis, WMA/WMV, MIDI i inne "            "(GStreamer – wszystkie zestawy wtyczek, FFmpeg z dodatkowymi kodekami).",            "Odtwarzanie płyt DVD (libdvdcss) i Blu-ray, zdjęcia HEIC z telefonów.",            "Sprzętowe dekodowanie wideo (VA-API, VDPAU) dla kart Intel, AMD i NVIDIA.",            "Miniatury filmów i zdjęć w Dolphinie; kodeki także dla programów Flatpak.",        ]),        ("Programy z Windows", [            "Wine (32 i 64 bit), winetricks i PlayOnLinux – do uruchamiania programów z Windows.",        ]),        ("Gry (gdy są w Twoim pakiecie)", [            "Steam, GameMode.",            "Proton: GE-Proton dla Steam + ProtonUp-Qt do jego aktualizacji (Proton od Valve "            "Steam pobiera sam).",            "Lutris – gry z EA App, Ubisoft Connect, Rockstar Games Launcher, Battle.net, GOG "            "i tysiące gotowych instalatorów z lutris.net.",            "Heroic Games Launcher – biblioteki Epic Games Store, GOG i Amazon Prime Gaming "            "(logowanie na swoje konto, darmowe gry z Epic też).",            "MangoHud (licznik FPS i obciążenia w grach) i GameMode – także dla Lutrisa i Heroic.",        ]),        ("Sklep z programami (Discover)", [            "Obsługa Flatpak (Flathub) i Snap (Snap Store) w Discover.",            "Pliki .deb będą domyślnie otwierane w Discover.",        ]),        ("Docker", [            "Docker Engine + Docker Compose (oficjalne repozytorium Docker) i Whaler "            "(graficzny menedżer kontenerów); użytkownicy dodani do grupy docker.",        ]),        ("Karta graficzna", grafika),        *([("DELL Unlock Pin ID", [            "Jeśli zasilacz nie jest rozpoznawany (uszkodzona linia ID w zasilaczu, kablu lub "            "gnieździe), Dell mocno spowalnia procesor. Program to wykryje i wyłączy spowolnienie "            "– ustawiane przy każdym starcie systemu, jeszcze przed logowaniem.",            "Ochrona procesora przed przegrzaniem działa dalej.",        ])] if jest_dell() else []),        *([("nVidia Unlock RTX (tylko jeśli się zgodzisz)", [            f"Karta {nazwa_karty(karta_rtx_do_odblokowania(sprzet)[0])}: osobna pozycja w menu startowym "            f"„{NVUNLOCK_POZYCJA}”. Zdejmuje fabryczne ograniczenie rdzeni Tensor – obliczenia AI "            "(lokalne modele językowe, generowanie obrazów) nawet 1,5–2× szybciej. Gier nie przyspiesza.",            "!Eksperymentalne narzędzie nv-uefi-unlocker, na własne ryzyko: na niektórych kartach "            "możliwy czarny ekran lub zawieszenie – wtedy wyłącz komputer przyciskiem i uruchom "            "zwykłą pozycję „Debian”. Wymaga wyłączonego Secure Boot.",        ])] if karta_rtx_do_odblokowania(sprzet) else []),        ("J.K. Anty-Kradzież (tylko jeśli się zgodzisz)", [            "Gdy zgłosisz kradzież lub zgubienie komputera, zablokujemy go przy najbliższym połączeniu "            "z internetem: nikt nie zaloguje się na żadne konto, na ekranie będzie Twoja wiadomość "            "dla znalazcy. Po odnalezieniu wszystko wraca do stanu sprzed blokady.",        ]),        ("Na koniec", [            "Ustawienia pulpitu (pasek, ulubione, ikony, kosz, motyw) zalogowane konta dostaną "            "od razu, pozostałe i nowe konta – przy pierwszym logowaniu.",            "Potrzebny będzie restart komputera.",            *(["Dodatki zainstalowane wcześniej, których tym razem nie wybierzesz albo których nie "               "ma już w Twoim pakiecie, zostaną usunięte razem z ich ustawieniami."] if wczytaj_dodatki()["zainstalowane"] else []),            f"Pełny dziennik zmian: {PLIK_DZIENNIKA}",        ]),    ]    # opcje spoza pakietu klienta – w ogóle o nich nie wspominamy    sekcje = [(t, p) for t, p in sekcje              if not any(t.startswith(TYTULY_OPCJI[o]) for o in TYTULY_OPCJI if o not in opcje)]    logitech = [o for o in OPCJE_LOGITECH if o in opcje]    for nr, (tytul, _) in enumerate(sekcje):        if tytul.startswith("Urządzenia Logitech"):            punkty = []            podswietlenie = [LOGITECH[o][0] for o in ("g213", "g102") if o in logitech]            if podswietlenie:                punkty.append(f"{' i '.join(podswietlenie)}: program „{PODSWIETLENIE_NAZWA}” do wyboru "                              "koloru i efektu; kolor ustawia się sam przy starcie komputera – jeszcze "                              "przed ekranem logowania.")            if "g19s" in logitech:                punkty.append("Logitech G19s: obsługa klawiszy G/M i wyświetlacza (g19daemon) – "                              "uruchamia się po zalogowaniu.")            sekcje[nr] = (tytul, punkty)    sekcje = [(t, p) for t, p in sekcje if p]    return ostrzezenia, sekcjedef opis_zmian_html(sprzet: Sprzet, nazwa: Optional[str] = None, opcje=OPCJE_PROGRAMU) -> str:    """Podsumowanie dla okna (prosty HTML obsługiwany przez QTextBrowser)."""    ostrzezenia, sekcje = zbuduj_opis_zmian(sprzet, nazwa, opcje)    czesci = []    for o in ostrzezenia:        czesci.append(f'<p style="color:#b71c1c;"><b>Uwaga:</b> {html.escape(o)}</p>')    for nr, (tytul, punkty) in enumerate(sekcje, 1):        czesci.append(f'<h3 style="color:#e65100; margin-top:14px; margin-bottom:4px;">'                      f'{nr}. {html.escape(tytul)}</h3><ul style="margin-top:0;">')        for p in punkty:            if p.startswith("!"):                czesci.append(f'<li><span style="color:#c62828;"><b>Uwaga:</b> '                              f'{html.escape(p[1:])}</span></li>')            else:                czesci.append(f"<li>{html.escape(p)}</li>")        czesci.append("</ul>")    return "".join(czesci)def opis_zmian_tekst(sprzet: Sprzet, nazwa: Optional[str] = None, opcje=OPCJE_PROGRAMU) -> str:    """Podsumowanie dla terminala."""    ostrzezenia, sekcje = zbuduj_opis_zmian(sprzet, nazwa, opcje)    linie = []    for o in ostrzezenia:        linie.append(f"!!! UWAGA: {o}")    for nr, (tytul, punkty) in enumerate(sekcje, 1):        linie.append(f"\n{nr}. {tytul.upper()}")        for p in punkty:            tekst = ("UWAGA: " + p[1:]) if p.startswith("!") else p            linie.append(textwrap.fill(tekst, width=88, initial_indent="   • ",                                       subsequent_indent="     "))    return "\n".join(linie)# ============================================================================# 4. NARZĘDZIA SYSTEMOWE (wykonawca – działa jako root)# ============================================================================SYMULACJA = False          # True = niczego nie zmieniamy, tylko opisujemyRAPORT = None              # obiekt Raport (sekcja 6)class BladPolecenia(Exception):    """Polecenie systemowe nie powiodło się."""class Ostrzezenie(Exception):    """Krok wykonany częściowo – tekst trafia do listy uwag."""class Pominiety(Exception):    """Krok nie dotyczy tego komputera."""def liczba(n: int, jeden: str, kilka: str, wiele: str) -> str:    """Polska odmiana: 1 konto, 2 konta, 5 kont, 22 konta."""    if n == 1:        forma = jeden    elif n % 10 in (2, 3, 4) and n % 100 not in (12, 13, 14):        forma = kilka    else:        forma = wiele    return f"{n} {forma}"def log(tekst: str) -> None:    if RAPORT:        RAPORT.log(tekst)    else:        print(tekst)def srodowisko_polecen() -> Dict[str, str]:    """Środowisko dla poleceń: bez pytań (noninteractive) i z angielskimi komunikatami,    które dają się wiarygodnie analizować (np. „Candidate:” w apt-cache policy)."""    env = dict(os.environ)    env.update({        "DEBIAN_FRONTEND": "noninteractive",        "LC_ALL": "C.UTF-8", "LANG": "C.UTF-8",        "PATH": "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",    })    return envdef uruchom(polecenie: List[str], *, sprawdz: bool = True, wejscie: Optional[str] = None,            srodowisko: Optional[Dict[str, str]] = None, cicho: bool = False,            tylko_odczyt: bool = False) -> Tuple[int, str]:    """Uruchamia polecenie, przekazując jego wyjście do dziennika.    sprawdz      – rzuć BladPolecenia, gdy kod wyjścia ≠ 0    tylko_odczyt – polecenie niczego nie zmienia, więc wykonujemy je również w symulacji    Zwraca (kod_wyjścia, całe_wyjście)."""    opis = " ".join(shlex.quote(x) for x in polecenie)    if SYMULACJA and not tylko_odczyt:        log(f"[symulacja] {opis}")        return 0, ""    if not cicho:        log(f"$ {opis}")    env = srodowisko_polecen()    env.update(srodowisko or {})    try:        proces = subprocess.Popen(            polecenie, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,            stdin=subprocess.PIPE if wejscie is not None else subprocess.DEVNULL,            text=True, errors="replace", env=env, bufsize=1)    except FileNotFoundError:        if sprawdz:            raise BladPolecenia(f"Brak programu: {polecenie[0]}")        return 127, ""    if wejscie is not None:        proces.stdin.write(wejscie)        proces.stdin.close()    wyjscie = []    for linia in proces.stdout:        for fragment in linia.rstrip("\n").split("\r"):            if fragment.strip():                wyjscie.append(fragment)                if not cicho:                    log(fragment)    kod = proces.wait()    if sprawdz and kod != 0:        raise BladPolecenia(f"Polecenie zakończone kodem {kod}: {opis}")    return kod, "\n".join(wyjscie)def systemctl(*argumenty: str) -> bool:    kod, _ = uruchom(["systemctl", *argumenty], sprawdz=False)    return kod == 0# --- Pliki -----------------------------------------------------------------def utworz_katalog(sciezka: str, wlasciciel: Optional["Uzytkownik"] = None) -> None:    """mkdir -p; nowe katalogi w katalogu domowym dostają właściciela-użytkownika."""    if not sciezka or os.path.isdir(sciezka):        return    if SYMULACJA:        log(f"[symulacja] utworzenie katalogu {sciezka}")        return    brakujace = []    biezaca = os.path.abspath(sciezka)    while biezaca and not os.path.isdir(biezaca):        brakujace.append(biezaca)        biezaca = os.path.dirname(biezaca)    for katalog in reversed(brakujace):        os.mkdir(katalog, 0o755)        if wlasciciel and katalog.startswith(wlasciciel.dom + "/"):            os.chown(katalog, wlasciciel.uid, wlasciciel.gid)def zapisz_plik(sciezka: str, tresc, tryb: int = 0o644,                wlasciciel: Optional["Uzytkownik"] = None) -> None:    """Bezpieczny zapis (plik tymczasowy + zamiana). tresc: str albo bytes."""    if SYMULACJA:        log(f"[symulacja] zapis pliku {sciezka}")        return    utworz_katalog(os.path.dirname(sciezka), wlasciciel)    tymczasowy = sciezka + ".jk-tmp"    with open(tymczasowy, "wb") as f:        f.write(tresc.encode("utf-8") if isinstance(tresc, str) else tresc)    os.chmod(tymczasowy, tryb)    if wlasciciel:        os.chown(tymczasowy, wlasciciel.uid, wlasciciel.gid)    os.replace(tymczasowy, sciezka)def kopiuj_plik(zrodlo: str, cel: str, tryb: int = 0o644,                wlasciciel: Optional["Uzytkownik"] = None) -> None:    if SYMULACJA:        log(f"[symulacja] kopiowanie {zrodlo} → {cel}")        return    with open(zrodlo, "rb") as f:        zapisz_plik(cel, f.read(), tryb, wlasciciel)def usun_plik(sciezka: str) -> None:    if not os.path.lexists(sciezka):        return    if SYMULACJA:        log(f"[symulacja] usunięcie {sciezka}")        return    if os.path.isdir(sciezka) and not os.path.islink(sciezka):        shutil.rmtree(sciezka, ignore_errors=True)    else:        os.remove(sciezka)def dowiazanie(cel: str, sciezka: str) -> None:    if os.path.lexists(sciezka):        return    if SYMULACJA:        log(f"[symulacja] dowiązanie {sciezka} → {cel}")        return    os.symlink(cel, sciezka)class IniPlik:    """Minimalny edytor plików INI w stylu KDE/XDG (kdeglobals, mimeapps.list…).    Zmienia tylko wskazane klucze, resztę pliku (komentarze, kolejność,    znaczniki KDE typu [$i]) zostawia bez zmian.    Grupy zagnieżdżone KDE, np. [AC][Display], podajemy jako "AC][Display"."""    def __init__(self, sciezka: str):        self.sciezka = sciezka        self.linie = czytaj(sciezka).splitlines()    def _zakres_grupy(self, grupa: str) -> Optional[Tuple[int, int]]:        naglowek = f"[{grupa}]"        for i, linia in enumerate(self.linie):            if linia.strip() == naglowek:                koniec = i + 1                while koniec < len(self.linie) and not self.linie[koniec].strip().startswith("["):                    koniec += 1                return i, koniec        return None    def grupy(self) -> List[str]:        return [l.strip()[1:-1] for l in self.linie                if l.strip().startswith("[") and l.strip().endswith("]")]    def pobierz(self, grupa: str, klucz: str) -> Optional[str]:        zakres = self._zakres_grupy(grupa)        if not zakres:            return None        for linia in self.linie[zakres[0] + 1:zakres[1]]:            if "=" in linia and linia.split("=", 1)[0].strip() == klucz:                return linia.split("=", 1)[1].strip()        return None    def ustaw(self, grupa: str, klucz: str, wartosc: str) -> None:        nowa = f"{klucz}={wartosc}"        zakres = self._zakres_grupy(grupa)        if not zakres:            if self.linie and self.linie[-1].strip():                self.linie.append("")            self.linie += [f"[{grupa}]", nowa]            return        poczatek, koniec = zakres        for i in range(poczatek + 1, koniec):            linia = self.linie[i]            if "=" in linia and linia.split("=", 1)[0].strip() == klucz:                self.linie[i] = nowa                return        # wstaw na końcu grupy, przed pustymi liniami oddzielającymi grupy        miejsce = koniec        while miejsce > poczatek + 1 and not self.linie[miejsce - 1].strip():            miejsce -= 1        self.linie.insert(miejsce, nowa)    def zapisz(self, wlasciciel: Optional["Uzytkownik"] = None) -> None:        zapisz_plik(self.sciezka, "\n".join(self.linie) + "\n", 0o644, wlasciciel)# --- Użytkownicy -------------------------------------------------------------@dataclassclass Uzytkownik:    nazwa: str    uid: int    gid: int    dom: str    def sciezka(self, *czesci: str) -> str:        return os.path.join(self.dom, *czesci)    def katalog_xdg(self, klucz: str, domyslny: str) -> str:        """Katalog XDG (np. XDG_PICTURES_DIR → ~/Obrazy) z ~/.config/user-dirs.dirs."""        tekst = czytaj(self.sciezka(".config", "user-dirs.dirs"))        m = re.search(rf'^{klucz}="([^"]*)"', tekst, re.M)        if m:            sciezka = m.group(1).replace("$HOME", self.dom)            if sciezka.rstrip("/") != self.dom.rstrip("/"):                return sciezka        return self.sciezka(domyslny)    @property    def zalogowany(self) -> bool:        return os.path.exists(f"/run/user/{self.uid}/bus")    @staticmethod    def biezacy() -> "Uzytkownik":        p = pwd.getpwuid(os.getuid())        return Uzytkownik(p.pw_name, p.pw_uid, p.pw_gid, p.pw_dir)def lista_uzytkownikow(glowny: Optional[str] = None) -> List[Uzytkownik]:    """Zwykłe konta (UID 1000–59999 z katalogiem domowym i powłoką logowania)."""    wynik = []    for p in pwd.getpwall():        if (1000 <= p.pw_uid < 60000 and os.path.isdir(p.pw_dir)                and not p.pw_shell.endswith(("nologin", "false"))                and re.fullmatch(r"[a-z_][a-z0-9_.-]*", p.pw_name)):            wynik.append(Uzytkownik(p.pw_name, p.pw_uid, p.pw_gid, p.pw_dir))    if glowny:        wynik.sort(key=lambda u: u.nazwa != glowny)   # osoba uruchamiająca – pierwsza        if not any(u.nazwa == glowny for u in wynik):            try:                p = pwd.getpwnam(glowny)                if p.pw_uid != 0:                    wynik.insert(0, Uzytkownik(p.pw_name, p.pw_uid, p.pw_gid, p.pw_dir))            except KeyError:                pass    return wynikdef jako_uzytkownik(u: Uzytkownik, polecenie: List[str], sesja: bool = False,                    **kwargs) -> Tuple[int, str]:    """Uruchamia polecenie jako użytkownik. sesja=True – z dostępem do jego sesji    pulpitu (D-Bus); gdy użytkownik nie jest zalogowany, zwraca (1, '')."""    env = ["env", f"HOME={u.dom}", f"USER={u.nazwa}", f"LOGNAME={u.nazwa}",           f"XDG_CONFIG_HOME={u.dom}/.config"]    if sesja:        if not u.zalogowany and not SYMULACJA:            return 1, ""        katalog = f"/run/user/{u.uid}"        env += [f"XDG_RUNTIME_DIR={katalog}", f"DBUS_SESSION_BUS_ADDRESS=unix:path={katalog}/bus"]    return uruchom(["runuser", "-u", u.nazwa, "--", *env, *polecenie], **kwargs)# --- APT -------------------------------------------------------------------APT_OPCJE = ["-y", "-o", "DPkg::Lock::Timeout=600",             "-o", "Dpkg::Options::=--force-confdef", "-o", "Dpkg::Options::=--force-confold"]def apt_update() -> None:    uruchom(["apt-get", "update", "-o", "DPkg::Lock::Timeout=600"])def kandydat(pakiet: str) -> Optional[str]:    """Wersja pakietu możliwa do instalacji albo None, gdy pakietu nie ma w repozytoriach."""    kod, wyjscie = uruchom(["apt-cache", "policy", pakiet], sprawdz=False, cicho=True,                           tylko_odczyt=True)    m = re.search(r"Candidate:\s*(\S+)", wyjscie)    wersja = None if not m or m.group(1) == "(none)" else m.group(1)    if SYMULACJA and wersja is None:        # w symulacji nie robimy „apt update” ani nie dodajemy repozytoriów,        # więc lokalna lista pakietów może być nieaktualna – zakładamy dostępność        return "(symulacja)"    return wersjadef dostepny(pakiet: str) -> bool:    return kandydat(pakiet) is not Nonedef zainstalowany(pakiet: str) -> bool:    kod, wyjscie = uruchom(["dpkg-query", "-W", "-f=${db:Status-Abbrev}", pakiet],                           sprawdz=False, cicho=True, tylko_odczyt=True)    return kod == 0 and wyjscie.startswith("ii")def apt_zainstaluj(wymagane: List[str], dodatkowe: List[str] = (),                   bez_polecanych: bool = False) -> List[str]:    """Instaluje pakiety. Brak pakietu wymaganego = błąd; dodatkowe niedostępne są    pomijane (np. pakiet, którego nie ma w tej wersji Debiana). Zwraca listę instalowanych."""    brakujace = [p for p in wymagane if not dostepny(p)]    if brakujace:        raise BladPolecenia("Brak w repozytoriach: " + ", ".join(brakujace))    dodatkowe_ok = [p for p in dodatkowe if dostepny(p)]    pominiete = [p for p in dodatkowe if p not in dodatkowe_ok]    if pominiete:        log("Pomijam niedostępne pakiety dodatkowe: " + ", ".join(pominiete))    pakiety = list(wymagane) + dodatkowe_ok    if pakiety:        uruchom(["apt-get", "install", *APT_OPCJE,                 *(["--no-install-recommends"] if bez_polecanych else []), *pakiety])    return pakietydef apt_zainstaluj_plik(sciezka: str) -> None:    """Instaluje lokalny plik .deb razem z zależnościami."""    uruchom(["apt-get", "install", *APT_OPCJE, os.path.abspath(sciezka)])def zainstalowane_wg_wzorcow(wzorce: List[str]) -> List[str]:    kod, wyjscie = uruchom(["dpkg-query", "-W", "-f=${binary:Package}\t${db:Status-Abbrev}\n",                            *wzorce], sprawdz=False, cicho=True, tylko_odczyt=True)    pakiety = []    for linia in wyjscie.splitlines():        czesci = linia.split("\t")        if len(czesci) == 2 and czesci[1].startswith("ii"):            pakiety.append(czesci[0])    return pakietydef apt_usun_bezpiecznie(wzorce: List[str]) -> List[str]:    """Usuwa (purge) zainstalowane pakiety pasujące do wzorców, chroniąc pulpit:    1) symulacja – czy apt nie chce przy okazji usunąć czegoś ważnego,    2) metapakiety usuwane „przy okazji” (np. task-…) – ich zależności oznaczamy jako       zainstalowane ręcznie, żeby późniejsze „autoremove” nie rozebrało systemu,    3) sprzątanie wyłącznie osieroconych bibliotek tych programów."""    pakiety = zainstalowane_wg_wzorcow(wzorce)    if not pakiety:        return []    nazwy = {p.split(":")[0] for p in pakiety}    _, sym = uruchom(["apt-get", "-s", "purge", *pakiety], sprawdz=False, cicho=True,                     tylko_odczyt=True)    usuwane = {m.group(2).split(":")[0] for m in re.finditer(r"^(Purg|Remv) (\S+)", sym, re.M)}    przy_okazji = sorted(usuwane - nazwy)    krytyczne = [p for p in przy_okazji if WZORZEC_KRYTYCZNYCH.match(p)]    if krytyczne:        raise Ostrzezenie("Pominięto – usunięcie pociągnęłoby za sobą ważne pakiety pulpitu: "                          + ", ".join(krytyczne))    if przy_okazji:        log("Razem z nimi zostaną usunięte metapakiety: " + ", ".join(przy_okazji))        do_oznaczenia = set()        for meta in przy_okazji:            _, zal = uruchom(["apt-cache", "depends", "--installed", "--no-suggests",                              "--no-conflicts", "--no-breaks", "--no-replaces", "--no-enhances",                              meta], sprawdz=False, cicho=True, tylko_odczyt=True)            for m in re.finditer(r"^\s+(?:Depends|Recommends|PreDepends):\s*<?([^\s>]+)>?", zal, re.M):                nazwa = m.group(1).split(":")[0]                if nazwa not in usuwane:                    do_oznaczenia.add(nazwa)        if do_oznaczenia:            uruchom(["apt-mark", "manual", *sorted(do_oznaczenia)], sprawdz=False, cicho=True)    uruchom(["apt-get", "purge", *APT_OPCJE, *pakiety])    # sprzątanie osieroconych bibliotek – tylko tych związanych z usuniętymi programami    _, sym = uruchom(["apt-get", "-s", "autoremove"], sprawdz=False, cicho=True, tylko_odczyt=True)    sieroty = [m.group(1) for m in re.finditer(r"^Remv (\S+)", sym, re.M)               if WZORZEC_SIEROT.match(m.group(1))]    if sieroty:        uruchom(["apt-get", "purge", *APT_OPCJE, *sieroty], sprawdz=False)    return pakietydef debconf_ustaw(linie: List[str]) -> None:    """Wstępne odpowiedzi na pytania instalatorów (np. licencja Steam)."""    uruchom(["debconf-set-selections"], wejscie="\n".join(linie) + "\n", sprawdz=False)# --- Pobieranie --------------------------------------------------------------def pobierz_json(url: str):    zadanie = urllib.request.Request(url, headers={"User-Agent": USER_AGENT,                                                   "Accept": "application/vnd.github+json"})    with urllib.request.urlopen(zadanie, timeout=30) as odp:        return json.load(odp)def pobierz_tekst(url: str) -> str:    zadanie = urllib.request.Request(url, headers={"User-Agent": USER_AGENT})    with urllib.request.urlopen(zadanie, timeout=30) as odp:        return odp.read().decode("utf-8", "replace")def pobierz_plik(url: str, cel: str) -> str:    """Pobiera plik, raportując postęp co 10%."""    if SYMULACJA:        log(f"[symulacja] pobieranie {url} → {cel}")        return cel    utworz_katalog(os.path.dirname(cel))    log(f"Pobieranie: {url}")    zadanie = urllib.request.Request(url, headers={"User-Agent": USER_AGENT})    czesc = cel + ".czesc"    with urllib.request.urlopen(zadanie, timeout=60) as odp, open(czesc, "wb") as f:        rozmiar = int(odp.headers.get("Content-Length") or 0)        pobrano, prog = 0, 10        while True:            blok = odp.read(1 << 16)            if not blok:                break            f.write(blok)            pobrano += len(blok)            if rozmiar and pobrano * 100 // rozmiar >= prog:                log(f"  pobrano {prog}% ({pobrano // 1048576} MB)")                prog += 10    os.replace(czesc, cel)    return celdef github_wydania(repo: str) -> list:    """Lista wydań z GitHub (łącznie z wersjami testowymi); [] gdy repozytorium nie istnieje."""    try:        dane = pobierz_json(f"https://api.github.com/repos/{repo}/releases?per_page=20")        return [w for w in dane if not w.get("draft")] if isinstance(dane, list) else []    except (urllib.error.URLError, OSError, ValueError) as e:        log(f"GitHub {repo}: {e}")        return []def tokeny_architektury() -> Tuple[str, ...]:    return {"amd64": ("amd64", "x86_64", "x64"),            "arm64": ("arm64", "aarch64")}.get(architektura(), (architektura(),))# --- Flatpak / Snap ----------------------------------------------------------def flatpak_zainstalowany(app_id: str) -> bool:    kod, _ = uruchom(["flatpak", "info", "--system", app_id], sprawdz=False, cicho=True,                     tylko_odczyt=True)    return kod == 0 and not SYMULACJAdef flatpak_zainstaluj(app_id: str) -> bool:    if flatpak_zainstalowany(app_id):        log(f"{app_id} jest już zainstalowany (Flatpak).")        return True    kod, _ = uruchom(["flatpak", "install", "-y", "--noninteractive", "--system", "flathub",                      app_id], sprawdz=False)    return kod == 0def snap_zainstaluj(nazwa: str, kanaly=("stable", "candidate", "beta", "edge")) -> bool:    """Próbuje kolejnych kanałów (aplikacje we wczesnym rozwoju bywają tylko w candidate/beta)."""    uruchom(["snap", "wait", "system", "seed.loaded"], sprawdz=False, cicho=True)    for kanal in kanaly:        kod, _ = uruchom(["snap", "install", nazwa, f"--{kanal}"], sprawdz=False)        if kod == 0:            return True    return False# --- Ustawienia KDE i skojarzenia plików --------------------------------------def ustaw_kde(k: "Kontekst", plik: str, ustawienia: Dict[str, Dict[str, str]],              systemowo: bool = True, uzytkownicy: bool = True) -> None:    """Zapisuje ustawienia KDE w /etc/xdg (domyślne dla nowych kont) i/lub u każdego    istniejącego użytkownika w ~/.config."""    cele = ([(f"/etc/xdg/{plik}", None)] if systemowo else []) + \           ([(u.sciezka(".config", plik), u) for u in k.uzytkownicy] if uzytkownicy else [])    for sciezka, wlasciciel in cele:        ini = IniPlik(sciezka)        for grupa, klucze in ustawienia.items():            for klucz, wartosc in klucze.items():                ini.ustaw(grupa, klucz, wartosc)        ini.zapisz(wlasciciel)def ustaw_skojarzenia(k: "Kontekst", mapowanie: Dict[str, str]) -> None:    """Ustawia domyślne programy dla typów MIME (mimeapps.list systemowo i u użytkowników)."""    cele = [("/etc/xdg/mimeapps.list", None)] + \           [(u.sciezka(".config", "mimeapps.list"), u) for u in k.uzytkownicy]    for sciezka, wlasciciel in cele:        ini = IniPlik(sciezka)        for mime, desktop in mapowanie.items():            ini.ustaw("Default Applications", mime, desktop + ";")            dodane = [d for d in (ini.pobierz("Added Associations", mime) or "").split(";")                      if d and d != desktop]            ini.ustaw("Added Associations", mime, ";".join([desktop] + dodane) + ";")        ini.zapisz(wlasciciel)KATALOGI_DESKTOP = ["/usr/share/applications", "/usr/local/share/applications",                    "/var/lib/snapd/desktop/applications",                    "/var/lib/flatpak/exports/share/applications"]def znajdz_plik_desktop(nazwa: str) -> Optional[str]:    """Znajduje plik .desktop programu (np. 'wordcraft' → 'wordcraft_wordcraft.desktop')."""    trafienia = []    for katalog in KATALOGI_DESKTOP:        for plik in glob.glob(os.path.join(katalog, "*.desktop")):            baza = os.path.basename(plik)            if nazwa.lower() in baza.lower():                trafienia.append(baza)    trafienia.sort(key=lambda b: (b.lower() != f"{nazwa}.desktop", len(b)))    return trafienia[0] if trafienia else None# ============================================================================# 5. KROKI# ============================================================================@dataclassclass Kontekst:    """Wszystko, czego potrzebują kroki."""    numlock: bool    uzytkownicy: List[Uzytkownik]    sprzet: Sprzet    katalog_tmp: str    nazwa: Optional[str] = None            # nowa nazwa komputera (None = bez zmian)    klucz: str = ""                        # aktywowany kod licencji    logitech: List[str] = field(default_factory=list)   # wybrane urządzenia Logitech    gry: bool = True                       # odpowiedź na „Czy zamierzasz grać w gry…?”    opcje: List[str] = field(default_factory=lambda: list(OPCJE_PROGRAMU))   # z licencji    nvidia_rtx: bool = False               # zgoda na nVidia Unlock RTX (na własne ryzyko)    antykradziez: bool = False             # zgoda na ochronę przed kradzieżą    grafika: Dict[str, str] = field(default_factory=dict)   # adresy z panelu (tapeta, logo_start, logo)    uwagi: List[str] = field(default_factory=list)    flagi: Dict[str, object] = field(default_factory=dict)    def uwaga(self, tekst: str) -> None:        if tekst not in self.uwagi:            self.uwagi.append(tekst)# --- Krok: repozytoria --------------------------------------------------------def popraw_deb822(tekst: str) -> Tuple[str, bool]:    """Plik .sources (format deb822): dopisuje brakujące składniki do repozytoriów    Debiana i wyłącza płytę instalacyjną. Zwraca (nowy_tekst, czy_jest_repozytorium_sieciowe)."""    if not tekst.strip():        return tekst, False    bloki = re.split(r"\n[ \t]*\n", tekst.strip("\n"))    nowe, siec = [], False    for blok in bloki:        linie = blok.split("\n")        pola = {}        for linia in linie:            m = re.match(r"^([A-Za-z-]+):\s*(.*)$", linia)            if m:                pola[m.group(1).lower()] = m.group(2)        uris = pola.get("uris", "")        wlaczony = pola.get("enabled", "yes").strip().lower() != "no"        if wlaczony and "cdrom:" in uris:            if "enabled" in pola:                linie = ["Enabled: no" if re.match(r"^Enabled:", l, re.I) else l for l in linie]            else:                linie.append("Enabled: no")        elif wlaczony and "components" in pola and czy_repo_debiana(uris, pola.get("suites", "")):            siec = True            skladniki = pola["components"].split()            brak = [s for s in SKLADNIKI_DEBIANA if s not in skladniki]            if brak:                nowe_skl = " ".join(skladniki + brak)                linie = [f"Components: {nowe_skl}" if re.match(r"^Components:", l, re.I) else l                         for l in linie]        nowe.append("\n".join(linie))    return "\n\n".join(nowe) + "\n", siecdef czy_repo_debiana(uri: str, suite: str) -> bool:    """Oficjalne repozytorium Debiana (także lustra) – ale nie repozytoria firm trzecich."""    if re.search(r"(docker|brave|nvidia|jablonski)", uri):        return False    if re.search(r"debian\.(org|net)", uri):        return True    kodowa = os_release().get("VERSION_CODENAME", "trixie")    return "/debian" in uri and any(s.startswith((kodowa, "stable")) for s in suite.split())def popraw_sources_list(tekst: str) -> Tuple[str, bool]:    """Stary format /etc/apt/sources.list – to samo co popraw_deb822()."""    wynik, siec = [], False    for linia in tekst.splitlines():        s = linia.strip()        if re.match(r"^deb(-src)?\s+(\[[^\]]*\]\s+)?cdrom:", s):            wynik.append(f"# {linia}   # wyłączone przez Optymalizator JK")            continue        m = re.match(r"^(deb(?:-src)?)\s+(\[[^\]]*\]\s+)?(\S+)\s+(\S+)\s*([^#]*?)\s*(#.*)?$", s)        if m and czy_repo_debiana(m.group(3), m.group(4)):            typ, opcje, uri, suite, skladniki, komentarz = m.groups()            skladniki = skladniki.split()            brak = [x for x in SKLADNIKI_DEBIANA if x not in skladniki]            if typ == "deb":                siec = True            linia = f"{typ} {opcje or ''}{uri} {suite} {' '.join(skladniki + brak)}"            if komentarz:                linia += f" {komentarz}"        wynik.append(linia)    return "\n".join(wynik) + ("\n" if wynik else ""), siecdef popraw_zrodla_apt() -> None:    kodowa = os_release().get("VERSION_CODENAME", "trixie")    jest_siec = False    for plik in sorted(glob.glob("/etc/apt/sources.list.d/*.sources")):        stary = czytaj(plik)        nowy, siec = popraw_deb822(stary)        jest_siec |= siec        if nowy != stary:            log(f"Aktualizuję {plik}")            zapisz_plik(plik, nowy)    plik = "/etc/apt/sources.list"    if os.path.exists(plik):        stary = czytaj(plik)        nowy, siec = popraw_sources_list(stary)        jest_siec |= siec        if nowy != stary:            log(f"Aktualizuję {plik}")            zapisz_plik(plik, nowy)    if not jest_siec:        log("Brak sieciowego repozytorium Debiana – dodaję standardowe.")        skl = " ".join(SKLADNIKI_DEBIANA)        zapisz_plik("/etc/apt/sources.list.d/jablonski-debian.sources", textwrap.dedent(f"""\            Types: deb            URIs: http://deb.debian.org/debian            Suites: {kodowa} {kodowa}-updates            Components: {skl}            Signed-By: /usr/share/keyrings/debian-archive-keyring.gpg            Types: deb            URIs: http://security.debian.org/debian-security            Suites: {kodowa}-security            Components: {skl}            Signed-By: /usr/share/keyrings/debian-archive-keyring.gpg            """))def krok_repozytoria(k: Kontekst) -> str:    if not SYMULACJA and not internet_dziala():        raise BladPolecenia("Brak połączenia z internetem – podłącz komputer do sieci "                            "i uruchom program ponownie.")    popraw_zrodla_apt()    if architektura() == "amd64":        _, obce = uruchom(["dpkg", "--print-foreign-architectures"], sprawdz=False,                          cicho=True, tylko_odczyt=True)        if "i386" not in obce.split():            uruchom(["dpkg", "--add-architecture", "i386"])    apt_update()    apt_zainstaluj(["ca-certificates", "curl", "gnupg", "pciutils", "xdg-utils",                    "xdg-user-dirs", "kbd", "debconf"],                   ["python3-pyqt6", "python3-pyqt6.qtwebengine", "mokutil", "packagekit"])    return "contrib, non-free, non-free-firmware i i386 włączone"# --- Krok: język polski --------------------------------------------------------def krok_jezyk(k: Kontekst) -> str:    apt_zainstaluj(["locales"])    gen = czytaj("/etc/locale.gen")    if not re.search(r"^\s*pl_PL\.UTF-8\s+UTF-8", gen, re.M):        nowy = re.sub(r"^#\s*(pl_PL\.UTF-8\s+UTF-8)", r"\1", gen, flags=re.M)        if nowy == gen:            nowy = gen.rstrip("\n") + "\npl_PL.UTF-8 UTF-8\n"        zapisz_plik("/etc/locale.gen", nowy)    uruchom(["locale-gen"])    uruchom(["update-locale", "LANG=pl_PL.UTF-8", "LANGUAGE=pl:en_US:en"])    zainst = apt_zainstaluj([], PAKIETY_JEZYKOWE, bez_polecanych=True)    # KDE: język i formaty dla każdego konta    ustaw_kde(k, "plasma-localerc", {"Formats": {"LANG": "pl_PL.UTF-8"},                                     "Translations": {"LANGUAGE": "pl"}})    # Układ klawiatury – zmieniamy tylko domyślny amerykański    klaw = czytaj("/etc/default/keyboard")    m = re.search(r'^XKBLAYOUT="?([^"\n]*)"?', klaw, re.M)    if m is None or m.group(1).strip() in ("", "us"):        if m:            klaw = klaw[:m.start()] + 'XKBLAYOUT="pl"' + klaw[m.end():]        else:            klaw = klaw.rstrip("\n") + '\nXKBLAYOUT="pl"\n'        zapisz_plik("/etc/default/keyboard", klaw)        uruchom(["setupcon", "--save"], sprawdz=False)        for u in k.uzytkownicy:            ini = IniPlik(u.sciezka(".config", "kxkbrc"))            if (ini.pobierz("Layout", "LayoutList") or "us") == "us":                ini.ustaw("Layout", "LayoutList", "pl")                ini.ustaw("Layout", "Use", "true")                ini.zapisz(u)    return f"pl_PL.UTF-8, {liczba(len(zainst), 'pakiet językowy', 'pakiety językowe', 'pakietów językowych')}"# --- Krok: Num Lock -------------------------------------------------------------USLUGA_NUMLOCK = "jablonski-numlock-tty.service"def krok_numlock(k: Kontekst) -> str:    stan = "on" if k.numlock else "off"    # Ekran logowania SDDM    zapisz_plik("/etc/sddm.conf.d/10-jablonski-numlock.conf",                f"# Jabłoński KOMPUTERY – Num Lock na ekranie logowania\n[General]\nNumlock={stan}\n")    # Plasma po zalogowaniu: 0 = włącz, 1 = wyłącz, 2 = nie zmieniaj    ustaw_kde(k, "kcminputrc", {"Keyboard": {"NumLock": "0" if k.numlock else "1"}})    # Konsole tekstowe (Ctrl+Alt+F2…)    sciezka = f"/etc/systemd/system/{USLUGA_NUMLOCK}"    if k.numlock:        zapisz_plik(sciezka, textwrap.dedent("""\            [Unit]            Description=Num Lock w konsolach tekstowych (Jabłoński KOMPUTERY)            After=systemd-vconsole-setup.service            [Service]            Type=oneshot            ExecStart=/bin/sh -c 'for t in /dev/tty[1-6]; do setleds -D +num < "$t"; done'            [Install]            WantedBy=multi-user.target            """))        systemctl("daemon-reload")        systemctl("enable", USLUGA_NUMLOCK)        return "Num Lock włączony: logowanie, pulpit i konsole"    if os.path.exists(sciezka):        systemctl("disable", USLUGA_NUMLOCK)        usun_plik(sciezka)        systemctl("daemon-reload")    return "Num Lock wyłączony (brak klawiatury numerycznej)"# --- Krok: hasło tylko raz -------------------------------------------------------# Hasło tylko raz – przy logowaniu. Odpowiednik ustawienia Kontroli konta użytkownika w Windows# „Nigdy nie powiadamiaj o instalacji oprogramowania i zmianach ustawień”: wszystko, co# administrator robi w okienkach (Discover, pobrane pliki .deb, Ustawienia systemowe, dyski,# drukarki, konta, Wi-Fi, GParted, Synaptic…), działa bez ponownego hasła.# Granice (świadome – to odróżnia regułę od „sudo bez hasła”):#   - tylko osoba siedząca przy komputerze: sesja lokalna i aktywna, konto w grupie sudo;#     połączenia zdalne (SSH), usługi w tle i inne konta – jak w czystym Debianie,#   - tylko akcje programów okienkowych z listy poniżej; ogólny pkexec, zarządzanie usługami#     systemd i zapis plików systemowych z edytora tekstu nadal wymagają hasła,#   - sudo w terminalu – z hasłem.REGULA_POLKIT = """\// Jabłoński KOMPUTERY – hasło tylko raz (przy logowaniu), jak w Windows z Kontrolą konta// użytkownika ustawioną na „Nigdy nie powiadamiaj”. Dotyczy wyłącznie administratora// siedzącego przy komputerze (sesja lokalna i aktywna) i programów okienkowych z listy.// Wszystko inne (ogólny pkexec, usługi systemd, SSH, sudo w terminalu) – jak w czystym Debianie.polkit.addRule(function(action, subject) {    if (!subject.local || !subject.active || !subject.isInGroup("sudo")) {        return polkit.Result.NOT_HANDLED;    }    var przedrostki = [        "org.freedesktop.packagekit.",       // Discover: programy, aktualizacje, pobrane pliki .deb        "org.freedesktop.Flatpak.",          // Discover: programy Flatpak        "io.snapcraft.snapd.",               // Discover: programy Snap        "org.freedesktop.udisks2.",          // pendrive'y, dyski, obrazy ISO, formatowanie        "org.freedesktop.NetworkManager.",   // Wi-Fi, sieci, VPN        "org.opensuse.cupspkhelper.mechanism.", // drukarki        "org.freedesktop.timedate1.",        // data i godzina        "org.freedesktop.timesync1.",        "org.freedesktop.locale1.",          // język i klawiatura        "org.freedesktop.hostname1.",        // nazwa komputera        "org.freedesktop.login1.",           // wyłączanie, ponowne uruchamianie, usypianie        "org.freedesktop.accounts.",         // Ustawienia → Użytkownicy (konta, hasła, autologowanie)        "org.kde.kcontrol.",                 // moduły Ustawień systemowych KDE (ekran logowania, zegar…)        "org.kde.ufw.",                      // Ustawienia → Zapora        "org.kde.kpmcore.",                  // Menedżer partycji KDE        "org.kde.fontinst",                  // instalowanie czcionek dla wszystkich        "org.kde.kinfocenter.",              // Ośrodek informacji        "org.kde.powerdevil."                // jasność ekranu, zasilanie    ];    var dozwolone = [        // Aktualizacje oprogramowania układowego – tylko podpisane (LVFS)        "org.freedesktop.fwupd.update-internal-trusted",        "org.freedesktop.fwupd.update-hotplug-trusted",        // GParted i Synaptic (sprawdzane niżej: tylko zwykłe otwarcie okna z menu)        "org.gnome.gparted",        "com.ubuntu.pkexec.synaptic"    ];    var id = action.id;    var pasuje = dozwolone.indexOf(id) >= 0;    for (var i = 0; !pasuje && i < przedrostki.length; i++) {        pasuje = id.indexOf(przedrostki[i]) == 0;    }    if (id == "org.gnome.gparted" || id == "com.ubuntu.pkexec.synaptic") {        // tylko otwarcie programu z menu – bez dodatkowych poleceń w wierszu        var wiersz = action.lookup("command_line") || "";        pasuje = /^\\/usr\\/(s?bin|libexec)\\/(gpartedbin|gparted|synaptic)( \\/dev\\/[A-Za-z0-9]+)*$/.test(wiersz);    }    return pasuje ? polkit.Result.YES : polkit.Result.NOT_HANDLED;});"""# sudo w terminalu: jak w każdym Linuksie pyta o hasło (to chroni przed złośliwymi poleceniami# przeklejonymi z internetu), ale jest wygodniej: widać gwiazdki przy wpisywaniu, a hasło# pamiętane jest przez 30 minut w danym oknie terminala.SUDOERS_ADMINISTRATORZY = "/etc/sudoers.d/90-jablonski-administratorzy"POLKIT_ADMINISTRATORZY = "/etc/polkit-1/rules.d/49-jablonski-administratorzy.rules"STARE_PLIKI_BEZ_HASLA = ("/etc/sudoers.d/90-jablonski-bez-hasla",                         "/etc/polkit-1/rules.d/49-jablonski-bez-hasla.rules")def krok_bez_hasla(k: Kontekst) -> str:    # 1) sudo: konta administratorów od razu (bez ponownego logowania), hasło jak w Debianie    linie = ["# Jabłoński KOMPUTERY – administratorzy tego komputera",             "# sudo pyta o hasło (standard Linuksa); widać gwiazdki, hasło ważne 30 min w oknie terminala",             "Defaults pwfeedback",             "Defaults timestamp_timeout=30"]    for u in k.uzytkownicy:        uruchom(["usermod", "-aG", "sudo", u.nazwa])        linie.append(f"{u.nazwa} ALL=(ALL:ALL) ALL")    tresc = "\n".join(linie) + "\n"    if not SYMULACJA:        with tempfile.NamedTemporaryFile("w", delete=False, suffix=".sudoers") as tmp:            tmp.write(tresc)        try:            uruchom(["visudo", "-cf", tmp.name], cicho=True)   # walidacja składni przed zapisem        finally:            os.remove(tmp.name)    zapisz_plik(SUDOERS_ADMINISTRATORZY, tresc, 0o440)    # 2) polkit – lista codziennych czynności bez ponownego hasła    zapisz_plik(POLKIT_ADMINISTRATORZY, REGULA_POLKIT)    for stary in STARE_PLIKI_BEZ_HASLA:               # wcześniejsza, ogólna wersja        usun_plik(stary)    # 3) portfel KWallet i blokada ekranu    ustaw_kde(k, "kwalletrc", {"Wallet": {"Enabled": "false", "First Use": "false"}})    ustaw_kde(k, "kscreenlockerrc", {"Daemon": {"Autolock": "false", "LockOnResume": "true"}})    odswiez_ustawienia_sesji(k)    k.uwaga("Hasła Wi-Fi zapisane wcześniej w portfelu KWallet trzeba będzie podać jeszcze raz "            "(jednorazowo).")    return (f"hasło tylko przy logowaniu dla codziennych czynności "            f"({liczba(len(k.uzytkownicy), 'konto', 'konta', 'kont')}), bez blokady ekranu i KWallet")# --- Krok: Snap i Flatpak w Discover ------------------------------------------------def krok_sklepy(k: Kontekst) -> str:    apt_zainstaluj(["flatpak", "snapd", "plasma-discover"],                   ["plasma-discover-backend-flatpak", "plasma-discover-backend-snap",                    "plasma-discover-backend-fwupd", "plasma-discover-backend-packagekit",                    "xdg-desktop-portal-kde", "packagekit"])    uruchom(["flatpak", "remote-add", "--if-not-exists", "--system", "flathub", FLATHUB_URL])    uruchom(["flatpak", "config", "--system", "--set", "languages", "pl;en"])    for usluga in ("snapd.socket", "snapd.service", "snapd.apparmor.service"):        systemctl("enable", "--now", usluga)    uruchom(["snap", "wait", "system", "seed.loaded"], sprawdz=False)    uruchom(["snap", "install", "snapd"], sprawdz=False)     # najnowszy snapd ze Snap Store    dowiazanie("/var/lib/snapd/snap", "/snap")               # dla aplikacji „classic”    k.uwaga("Programy Snap pojawią się w menu po ponownym zalogowaniu.")    return "Flathub i Snap Store dostępne w Discover"# --- Krok: Brave -------------------------------------------------------------------def krok_brave(k: Kontekst) -> str:    arch = architektura()    juz_jest = any("brave-browser-apt-release" in czytaj(p)                   for p in glob.glob("/etc/apt/sources.list.d/*"))    if not juz_jest:        pobierz_plik(BRAVE_KLUCZ_URL, BRAVE_KLUCZ)        zapisz_plik("/etc/apt/sources.list.d/brave-browser-release.list",                    f"deb [signed-by={BRAVE_KLUCZ} arch={arch}] {BRAVE_REPO} stable main\n")        apt_update()    apt_zainstaluj(["brave-browser"])    # Zasady (policies) – obowiązkowa zakładka i zalecana strona startowa    # (zalecane = ustawione domyślnie, użytkownik może je zmienić).    obowiazkowe = {        "ManagedBookmarks": [{"toplevel_name": BRAVE_FOLDER_ZAKLADEK}] +                            [{"name": n, "url": u} for n, u in BRAVE_ZAKLADKI],    }    zalecane = {        "HomepageLocation": BRAVE_STRONA_STARTOWA,        "HomepageIsNewTabPage": False,        "ShowHomeButton": True,        "RestoreOnStartup": 4,                       # 4 = otwórz określone strony        "RestoreOnStartupURLs": [BRAVE_STRONA_STARTOWA],        "BookmarkBarEnabled": True,    }    zapisz_plik("/etc/brave/policies/managed/jablonski-komputery.json",                json.dumps(obowiazkowe, ensure_ascii=False, indent=2) + "\n")    zapisz_plik("/etc/brave/policies/recommended/jablonski-komputery.json",                json.dumps(zalecane, ensure_ascii=False, indent=2) + "\n")    # Domyślna przeglądarka: XDG, KDE i alternatywy Debiana    ustaw_skojarzenia(k, {m: BRAVE_DESKTOP for m in MIME_PRZEGLADARKA})    ustaw_kde(k, "kdeglobals", {"General": {"BrowserApplication": BRAVE_DESKTOP}})    for alternatywa in ("x-www-browser", "gnome-www-browser"):        uruchom(["update-alternatives", "--set", alternatywa, "/usr/bin/brave-browser-stable"],                sprawdz=False, cicho=True)    return "zainstalowana, domyślna, zakładki i strona startowa ustawione"# --- Kroki: ArtCraft -------------------------------------------------------------------def znajdz_paczki_artcraft(app_id: str) -> Tuple[Optional[str], Optional[str]]:    """Adresy (deb, appimage) najnowszego wydania z paczkami dla Linuksa.    Szuka w repozytorium aplikacji, a potem we wspólnym repozytorium ArtCraft."""    tokeny = tokeny_architektury()    for repo in (f"{ARTCRAFT_ORGANIZACJA}/{app_id}", f"{ARTCRAFT_ORGANIZACJA}/artcraft"):        for wydanie in github_wydania(repo):            deb = appimage = None            for zasob in wydanie.get("assets", []):                nazwa = zasob.get("name", "").lower()                if app_id not in nazwa or not any(t in nazwa for t in tokeny):                    continue                if nazwa.endswith(".deb"):                    deb = deb or zasob["browser_download_url"]                elif nazwa.endswith(".appimage"):                    appimage = appimage or zasob["browser_download_url"]            if deb or appimage:                log(f"Znaleziono wydanie {wydanie.get('tag_name')} w {repo}")                return deb, appimage    return None, Nonedef zainstaluj_artcraft(k: Kontekst, a: AplikacjaArtCraft) -> Tuple[str, Optional[str]]:    """Kolejność prób: paczka .deb z GitHub → AppImage z GitHub → Snap.    Zwraca (sposób, plik .desktop)."""    istniejacy = znajdz_plik_desktop(a.id)    if istniejacy and not SYMULACJA:        return "już zainstalowany", istniejacy    deb, appimage = znajdz_paczki_artcraft(a.id)    if deb:        plik = pobierz_plik(deb, os.path.join(k.katalog_tmp, os.path.basename(deb)))        apt_zainstaluj_plik(plik)        return "paczka .deb", znajdz_plik_desktop(a.id) or f"{a.id}.desktop"    if appimage:        apt_zainstaluj([], ["libfuse2t64", "libfuse2"])        # AppImage potrzebuje FUSE 2        cel = f"/opt/artcraft/{a.id}/{a.nazwa}.AppImage"        pobierz_plik(appimage, cel)        if not SYMULACJA:            os.chmod(cel, 0o755)        desktop = f"artcraft-{a.id}.desktop"        zapisz_plik(f"/usr/share/applications/{desktop}", textwrap.dedent(f"""\            [Desktop Entry]            Type=Application            Name={a.nazwa}            GenericName={a.opis}            Comment=ArtCraft {a.nazwa} – {a.opis}            Exec="{cel}" %F            Icon={a.ikona}            Terminal=false            Categories=Office;            MimeType={";".join(a.mime)};            """))        return "AppImage", desktop    if snap_zainstaluj(a.id):        return "Snap", znajdz_plik_desktop(a.id) or f"{a.id}_{a.id}.desktop"    raise BladPolecenia(f"Nie znaleziono paczki {a.nazwa} dla Linuksa "                        f"(GitHub {ARTCRAFT_ORGANIZACJA}/{a.id}, Snap Store).")def zrob_krok_artcraft(a: AplikacjaArtCraft) -> Callable[[Kontekst], str]:    def krok(k: Kontekst) -> str:        sposob, desktop = zainstaluj_artcraft(k, a)        if a.domyslna and desktop:            ustaw_skojarzenia(k, {m: desktop for m in a.mime})            return f"{sposob}; domyślny program dla swoich plików"        return sposob    krok.__name__ = f"krok_{a.id}"    return krok# --- Krok: sterowniki grafiki ------------------------------------------------------------def dodaj_repo_nvidia(k: Kontekst) -> bool:    """Oficjalne repozytorium NVIDIA (CUDA) dla Debiana. Wynik zapamiętujemy w k.flagi."""    if "repo_nvidia" in k.flagi:        return bool(k.flagi["repo_nvidia"])    system = os_release()    dystr = "debian" + (system.get("VERSION_ID", "13") if system.get("ID") == "debian" else "13")    arch = {"amd64": "x86_64", "arm64": "sbsa"}.get(architektura(), "x86_64")    baza = NVIDIA_REPO.format(dystr=dystr, arch=arch)    try:        plik_keyring = "cuda-keyring_1.1-1_all.deb"        try:   # najnowsza wersja pakietu z kluczem – z listy plików repozytorium            wersje = sorted(set(re.findall(r"cuda-keyring_[\d.]+-\d+_all\.deb", pobierz_tekst(baza))))            if wersje:                plik_keyring = wersje[-1]        except (urllib.error.URLError, OSError) as e:            log(f"Nie odczytano listy plików repozytorium NVIDIA: {e}")        plik = pobierz_plik(baza + plik_keyring, os.path.join(k.katalog_tmp, plik_keyring))        uruchom(["dpkg", "-i", plik])        apt_update()        k.flagi["repo_nvidia"] = True    except (BladPolecenia, urllib.error.URLError, OSError) as e:        log(f"Repozytorium NVIDIA niedostępne: {e}")        k.flagi["repo_nvidia"] = False    return bool(k.flagi["repo_nvidia"])def usun_repo_nvidia(k: Kontekst) -> None:    """Usuwa repozytorium NVIDIA (np. gdy nie ma w nim gałęzi dla starszej karty –    inaczej apt zainstalowałby nowszy sterownik, który tej karty już nie obsługuje)."""    if k.flagi.get("repo_nvidia"):        uruchom(["apt-get", "purge", *APT_OPCJE, "cuda-keyring"], sprawdz=False)        apt_update()        k.flagi["repo_nvidia"] = Falsedef doinstaluj_nvidia_32bit(pakiet: str = "nvidia-driver-libs") -> None:    """32-bitowe biblioteki NVIDIA (klient Steam, gry 32-bit, Wine). Osobnym poleceniem    i tylko w wersji identycznej ze sterownikiem – niezgodność nie może zablokować    instalacji samego sterownika."""    if architektura() != "amd64":        return    w64, w32 = kandydat(pakiet), kandydat(f"{pakiet}:i386")    if w64 and w32 and w64 == w32:        uruchom(["apt-get", "install", *APT_OPCJE, f"{pakiet}:i386"], sprawdz=False)    else:        log(f"Pomijam 32-bitowe biblioteki NVIDIA (64-bit: {w64}, 32-bit: {w32}).")def zainstaluj_nvidia_z_debiana() -> str:    apt_zainstaluj(["nvidia-driver", "nvidia-kernel-dkms"],                   ["nvidia-settings", "nvidia-suspend-common", "firmware-misc-nonfree"])    return f"NVIDIA {kandydat('nvidia-driver')} (repozytorium Debiana)"def obsluz_secure_boot(k: Kontekst) -> None:    """Przy włączonym Secure Boot moduły DKMS muszą być podpisane kluczem MOK,    który trzeba raz zatwierdzić przy starcie komputera."""    _, stan = uruchom(["mokutil", "--sb-state"], sprawdz=False, cicho=True, tylko_odczyt=True)    if "enabled" not in stan.lower():        return    klucz = "/var/lib/dkms/mok.pub"    if not os.path.exists(klucz):        uruchom(["dkms", "generate_mok"], sprawdz=False)    if not os.path.exists(klucz) and not SYMULACJA:        k.uwaga("Secure Boot jest włączony, a nie udało się przygotować klucza podpisu "                "sterownika – wyłącz Secure Boot w BIOS/UEFI, aby sterownik NVIDIA działał.")        return    _, test = uruchom(["mokutil", "--test-key", klucz], sprawdz=False, cicho=True,                      tylko_odczyt=True)    if "already enrolled" in test:        return    _, skrot = uruchom(["mokutil", f"--generate-hash={HASLO_MOK}"], cicho=True)    plik_skrotu = os.path.join(k.katalog_tmp, "mok.hash")    zapisz_plik(plik_skrotu, skrot.strip() + "\n", 0o600)    uruchom(["mokutil", "--import", klucz, "--hash-file", plik_skrotu])    k.uwaga(f"SECURE BOOT: po restarcie pojawi się niebieski ekran „MOK management”. Wybierz "            f"„Enroll MOK” → „Continue” → „Yes”, wpisz hasło: {HASLO_MOK} i wybierz „Reboot”. "            f"Bez tego sterownik NVIDIA się nie uruchomi.")PRIME_RUN = """\#!/bin/sh# Jabłoński KOMPUTERY – uruchamia program na karcie NVIDIA (PRIME Render Offload).# Przykład w Steam (Właściwości gry → Opcje uruchamiania):  prime-run %command%export __NV_PRIME_RENDER_OFFLOAD=1export __GLX_VENDOR_LIBRARY_NAME=nvidiaexport __VK_LAYER_NV_optimus=NVIDIA_onlyexec "$@""""def konfiguruj_nvidia(k: Kontekst, karta: KartaGraficzna) -> None:    drm = "options nvidia-drm modeset=1" + ("" if karta.klasa_nvidia == NV_KEPLER else " fbdev=1")    opcje = ["# Jabłoński KOMPUTERY – ustawienia sterownika NVIDIA",             "# modeset (i fbdev od sterownika 545): obraz od startu i Wayland w KDE Plasma",             drm,             "# zachowanie pamięci karty przy usypianiu (brak artefaktów po wybudzeniu)",             "options nvidia NVreg_PreserveVideoMemoryAllocations=1"]    if k.sprzet.laptop and karta.klasa_nvidia in (NV_TURING_ADA, NV_NAJNOWSZA):        opcje += ["# laptop: wyłączanie karty NVIDIA, gdy nic jej nie używa",                  "options nvidia NVreg_DynamicPowerManagement=0x02"]    zapisz_plik("/etc/modprobe.d/jablonski-nvidia.conf", "\n".join(opcje) + "\n")    for usluga in ("nvidia-suspend.service", "nvidia-hibernate.service", "nvidia-resume.service"):        systemctl("enable", usluga)    if k.sprzet.hybryda:        zapisz_plik("/usr/local/bin/prime-run", PRIME_RUN, 0o755)        k.uwaga("Laptop z dwiema kartami: programy domyślnie działają na karcie zintegrowanej. "                "Gry na NVIDIA: w Steam → Właściwości gry → Opcje uruchamiania wpisz "                "„prime-run %command%”; inne programy – prawy przycisk w menu → „Uruchom na "                "dedykowanej karcie graficznej”.")def wstrzymaj_aktualizacje(wzorce: List[str]) -> List[str]:    """apt-mark hold – Debian nie zaktualizuje tych pakietów (np. sterownika 470)."""    pakiety = zainstalowane_wg_wzorcow(wzorce) or (["(symulacja)"] if SYMULACJA else [])    if pakiety and not SYMULACJA:        uruchom(["apt-mark", "hold", *pakiety])    elif SYMULACJA:        log(f"[symulacja] apt-mark hold {' '.join(wzorce)}")    return pakietydef ustaw_sesje_x11(k: Kontekst, powod: str) -> str:    """Domyślna sesja pulpitu: Plasma X11 (np. sterownik 470 nie działa pod Wayland).    Użytkownik nadal może wybrać sesję na ekranie logowania."""    apt_zainstaluj([], ["kwin-x11", "plasma-session-x11", "plasma-workspace-x11",                        "xserver-xorg-core", "xserver-xorg-input-all"])    sesja = next((os.path.basename(p) for p in ("/usr/share/xsessions/plasmax11.desktop",                                                "/usr/share/xsessions/plasma.desktop")                  if os.path.exists(p)), "plasmax11.desktop")    zapisz_plik("/etc/sddm.conf.d/30-jablonski-sesja-x11.conf",                f"# Jabłoński KOMPUTERY – {powod}\n[General]\nDefaultSession={sesja}\n")    stan = IniPlik("/var/lib/sddm/state.conf")          # ostatnio wybrana sesja na ekranie logowania    stan.ustaw("Last", "Session", f"/usr/share/xsessions/{sesja}")    stan.zapisz()    if not SYMULACJA and os.path.exists("/var/lib/sddm/state.conf"):        try:            p = pwd.getpwnam("sddm")            os.chown("/var/lib/sddm/state.conf", p.pw_uid, p.pw_gid)        except KeyError:            pass    return sesjadef zainstaluj_nvidia_470(k: Kontekst, karta: KartaGraficzna) -> str:    """Kepler (np. GTX 770): zamknięty sterownik 470 z Debiana, aktualizacje wstrzymane,    sesja X11 (sterownik 470 nie obsługuje Wayland w KDE Plasma 6)."""    if not dostepny("nvidia-tesla-470-driver"):        apt_zainstaluj([], ["firmware-misc-nonfree", "xserver-xorg-video-nouveau"])        k.uwaga(f"{karta.krotka_nazwa}: w repozytorium nie ma sterownika NVIDIA 470 – działa "                f"otwarty sterownik nouveau (gry 3D będą wolniejsze).")        return "nouveau (brak pakietu nvidia-tesla-470-driver)"    apt_zainstaluj(["nvidia-tesla-470-driver", "nvidia-tesla-470-kernel-dkms"],                   ["nvidia-settings-tesla-470", "firmware-misc-nonfree"])    doinstaluj_nvidia_32bit("nvidia-tesla-470-driver-libs")    wstrzymane = wstrzymaj_aktualizacje(["*tesla-470*", "nvidia-settings-tesla-470"])    sesja = ustaw_sesje_x11(k, "sterownik NVIDIA 470 działa tylko w sesji X11")    k.uwaga(f"{karta.krotka_nazwa}: zainstalowano sterownik NVIDIA 470 (ostatni dla tej karty), "            f"a jego aktualizacje wstrzymano ({liczba(len(wstrzymane), 'pakiet', 'pakiety', 'pakietów')}, apt-mark hold). Pulpit "            f"uruchamia się w sesji X11 ({sesja}) – Wayland z tym sterownikiem nie działa. "            "Aby kiedyś zdjąć blokadę: sudo apt-mark unhold $(apt-mark showhold | grep tesla-470)")    return f"NVIDIA {kandydat('nvidia-tesla-470-driver')} (Debian, zamknięty; aktualizacje wstrzymane; X11)"def zainstaluj_nvidia(k: Kontekst, karta: KartaGraficzna) -> str:    klasa = karta.klasa_nvidia    if klasa == NV_STARA:        apt_zainstaluj([], ["firmware-misc-nonfree", "xserver-xorg-video-nouveau"])        k.uwaga(f"{karta.krotka_nazwa}: NVIDIA nie wydaje sterownika tej karty dla Debiana 13 – "                f"działa otwarty sterownik nouveau (gry 3D będą wolniejsze).")        return "nouveau (brak sterownika NVIDIA dla tej karty)"    arch = architektura()    apt_zainstaluj([f"linux-headers-{arch}"], [f"linux-headers-{os.uname().release}", "dkms"])    if klasa == NV_KEPLER:        opis = zainstaluj_nvidia_470(k, karta)        if "nouveau" in opis:            return opis        konfiguruj_nvidia(k, karta)        obsluz_secure_boot(k)        k.flagi["initramfs"] = True        return opis    if klasa in (NV_NAJNOWSZA, NV_TURING_ADA):        if dodaj_repo_nvidia(k):            if dostepny("nvidia-kernel-open-dkms"):                apt_zainstaluj(["nvidia-driver", "nvidia-kernel-open-dkms"],                               ["nvidia-settings", "nvidia-driver-cuda", "nvidia-suspend-common"])            else:                apt_zainstaluj(["nvidia-open"])            opis = f"NVIDIA {kandydat('nvidia-driver')} (repozytorium NVIDIA, moduły otwarte)"        elif klasa == NV_TURING_ADA:            opis = zainstaluj_nvidia_z_debiana()        else:            raise BladPolecenia("Repozytorium NVIDIA jest niedostępne, a karty RTX 50 i nowsze "                                "wymagają sterownika 570+ (Debian 13 ma 550).")    else:        # Maxwell, Pascal, Volta (np. GTX 970, GTX 1080 Ti): sterownik 550 z Debiana.        # Repozytorium NVIDIA dla Debiana 13 ma tylko gałęzie 590+, które tych kart już nie        # obsługują (gałąź 580 jest tam wyłącznie dla Debiana 12) – nie wolno go dodawać,        # bo apt podmieniłby sterownik na niedziałający.        if zainstalowany("cuda-keyring"):            k.flagi["repo_nvidia"] = True            usun_repo_nvidia(k)        opis = zainstaluj_nvidia_z_debiana()        if SESJA_X11_DLA_550:            ustaw_sesje_x11(k, "sterownik NVIDIA 550 – najstabilniejszy w sesji X11")            opis += "; sesja X11"            k.uwaga(f"{karta.krotka_nazwa}: sterownik NVIDIA 550 z Debiana; domyślna sesja pulpitu "                    "to X11 (pod Wayland ten sterownik powoduje migotanie w grach). Sesję Wayland "                    "można wybrać na ekranie logowania.")    doinstaluj_nvidia_32bit()    konfiguruj_nvidia(k, karta)    obsluz_secure_boot(k)    k.flagi["initramfs"] = True    return opisdef zainstaluj_amd(k: Kontekst, karta: KartaGraficzna) -> str:    apt_zainstaluj(["firmware-amd-graphics"],                   ["xserver-xorg-video-amdgpu", "xserver-xorg-video-radeon", "mesa-va-drivers",                    "mesa-vdpau-drivers", "libdrm-amdgpu1", "radeontop"])    if karta.klasa_amd == "si_cik":        zapisz_plik("/etc/modprobe.d/jablonski-amdgpu.conf", textwrap.dedent("""\            # Jabłoński KOMPUTERY – karty GCN 1/2 obsługiwane przez amdgpu (Vulkan) zamiast radeon            options amdgpu si_support=1 cik_support=1            options radeon si_support=0 cik_support=0            """))        k.flagi["initramfs"] = True        return "amdgpu z obsługą GCN 1/2 (Vulkan)"    return "amdgpu + Mesa" if karta.klasa_amd == "amdgpu" else "radeon + Mesa"def zainstaluj_intel(k: Kontekst, karta: KartaGraficzna) -> str:    apt_zainstaluj([], ["intel-media-va-driver-non-free", "i965-va-driver-shaders",                        "firmware-intel-graphics", "firmware-misc-nonfree"])    return "Mesa + VA-API"def krok_grafika(k: Kontekst) -> str:    karty = k.sprzet.karty    if not karty:        raise Pominiety("nie wykryto karty graficznej")    wspolne = ["mesa-vulkan-drivers", "libgl1-mesa-dri", "mesa-utils", "vulkan-tools",               "firmware-misc-nonfree"]    if architektura() == "amd64":   # 32-bitowe biblioteki dla Steam i Wine        wspolne += ["mesa-vulkan-drivers:i386", "libgl1-mesa-dri:i386", "libglx-mesa0:i386"]    apt_zainstaluj([], wspolne)    wyniki, bledy = [], []    for karta in karty:        instalator = {"nvidia": zainstaluj_nvidia, "amd": zainstaluj_amd,                      "intel": zainstaluj_intel}.get(karta.producent)        if not instalator:            wyniki.append(f"{karta.krotka_nazwa}: bez zmian")            continue        try:            wyniki.append(f"{karta.krotka_nazwa}: {instalator(k, karta)}")        except (BladPolecenia, Ostrzezenie) as e:            bledy.append(f"{karta.krotka_nazwa}: {e}")    if k.sprzet.hybryda:        apt_zainstaluj([], ["switcheroo-control"])        systemctl("enable", "--now", "switcheroo-control.service")    if k.flagi.get("initramfs"):        uruchom(["update-initramfs", "-u"], sprawdz=False)    if bledy:        raise Ostrzezenie("; ".join(wyniki + bledy))    return "; ".join(wyniki)# --- Kroki: programy z repozytorium Debiana -------------------------------------------------def zrob_krok_apt(wymagane: List[str], dodatkowe: List[str]) -> Callable[[Kontekst], str]:    def krok(k: Kontekst) -> str:        apt_zainstaluj(wymagane, dodatkowe)        return f"wersja {kandydat(wymagane[0])}"    return krokdef krok_kodeki(k: Kontekst) -> str:    oznacz_dodatek("multimedia")    # libdvdcss (płyty DVD): libdvd-pkg pobiera i kompiluje go przy instalacji – bez pytań    debconf_ustaw(["libdvd-pkg libdvd-pkg/first-install note",                   "libdvd-pkg libdvd-pkg/post-invoke_hook-install boolean true"])    try:        instalowane = apt_zainstaluj(KODEKI_WYMAGANE, KODEKI_DODATKOWE)    except BladPolecenia as e:    # konflikt któregoś dodatku nie może zablokować podstawowych kodeków        log(f"Kodeki dodatkowe: {e} – instaluję same podstawowe.")        instalowane = apt_zainstaluj(KODEKI_WYMAGANE)        k.uwaga("Część dodatkowych kodeków nie dała się zainstalować – szczegóły w dzienniku.")    if zainstalowany("libdvd-pkg") or "libdvd-pkg" in instalowane or SYMULACJA:        kod, _ = uruchom(["dpkg-reconfigure", "-f", "noninteractive", "libdvd-pkg"], sprawdz=False)        if kod != 0:            k.uwaga("Nie udało się zbudować libdvdcss – zaszyfrowane płyty DVD mogą się nie odtwarzać "                    "(spróbuj: sudo dpkg-reconfigure libdvd-pkg).")    flatpak = [f for f in FLATPAK_KODEKI if flatpak_zainstaluj(f)]    return ("GStreamer, FFmpeg (libavcodec-extra), DVD/Blu-ray, VA-API/VDPAU"            + (", kodeki Flatpak" if flatpak else ""))def krok_nextcloud(k: Kontekst) -> str:    if dostepny("nextcloud-desktop"):        apt_zainstaluj(["nextcloud-desktop"], ["nextcloud-desktop-l10n", "dolphin-nextcloud"])        return "z repozytorium Debiana (+ integracja z Dolphinem)"    if flatpak_zainstaluj(FLATPAK_NEXTCLOUD):        return "Flatpak (Flathub)"    raise BladPolecenia("Nie udało się zainstalować klienta Nextcloud.")def krok_rustdesk(k: Kontekst) -> str:    wynik = _zainstaluj_rustdesk(k)    systemctl("enable", "--now", "rustdesk.service")     # ID RustDesk powstaje po pierwszym starcie    return wynikdef _zainstaluj_rustdesk(k: Kontekst) -> str:    if zainstalowany("rustdesk"):        return "już zainstalowany"    tokeny = tokeny_architektury()    try:        wydanie = pobierz_json("https://api.github.com/repos/rustdesk/rustdesk/releases/latest")        for zasob in wydanie.get("assets", []):            nazwa = zasob["name"].lower()            if nazwa.endswith(".deb") and any(t in nazwa for t in tokeny) and "sciter" not in nazwa:                plik = pobierz_plik(zasob["browser_download_url"],                                    os.path.join(k.katalog_tmp, zasob["name"]))                apt_zainstaluj_plik(plik)                return f"{wydanie.get('tag_name')} (.deb z GitHub)"    except (urllib.error.URLError, OSError, ValueError, BladPolecenia) as e:        log(f"RustDesk z GitHub nie powiódł się: {e}")    if flatpak_zainstaluj(FLATPAK_RUSTDESK):        return "Flatpak (Flathub)"    raise BladPolecenia("Nie udało się zainstalować RustDesk.")# --- Krok: Steam --------------------------------------------------------------------------def krok_steam(k: Kontekst) -> str:    if not k.gry:        raise Pominiety("bez gier – wybrano „Nie”")    if architektura() != "amd64":        raise Pominiety("Steam działa tylko na komputerach x86-64")    oznacz_dodatek("gry")    debconf_ustaw([        "steam steam/question select I AGREE",        "steam steam/license note ",        "steam-installer steam/question select I AGREE",        "steam-installer steam/license note ",    ])    apt_zainstaluj(["steam-installer"], ["steam-devices", "gamemode", "mesa-vulkan-drivers:i386",                                         "libgl1-mesa-dri:i386", "libglx-mesa0:i386"])    k.uwaga("Steam przy pierwszym uruchomieniu pobierze swoje aktualizacje. Jeśli wyświetli "            "się po angielsku: Steam → Settings → Interface → Language → Polski.")    return "zainstalowany (+ GameMode)"# --- Krok: Wine, PlayOnLinux, Proton -------------------------------------------------------def zainstaluj_ge_proton(k: Kontekst) -> str:    """GE-Proton do katalogu systemowego Steam – dostępny dla wszystkich kont."""    wydanie = pobierz_json(        "https://api.github.com/repos/GloriousEggroll/proton-ge-custom/releases/latest")    tag = wydanie.get("tag_name", "GE-Proton")    if os.path.isdir(os.path.join(KATALOG_PROTON, tag)):        return f"{tag} (już był)"    zasob = next((z for z in wydanie.get("assets", []) if z["name"].endswith(".tar.gz")), None)    if not zasob:        raise BladPolecenia("brak archiwum GE-Proton w wydaniu")    plik = pobierz_plik(zasob["browser_download_url"], os.path.join(k.katalog_tmp, zasob["name"]))    utworz_katalog(KATALOG_PROTON)    uruchom(["tar", "-xzf", plik, "-C", KATALOG_PROTON])    usun_plik(plik)    return tagdef krok_launchery_gier(k: Kontekst) -> str:    if not k.gry:        raise Pominiety("bez gier – wybrano „Nie”")    oznacz_dodatek("gry")    apt_zainstaluj([], ["gamemode", "mangohud", "mangohud:i386", "vulkan-tools"])    zainstalowane, problemy = [], []    for app_id, nazwa_g in FLATPAK_GRY:        (zainstalowane if flatpak_zainstaluj(app_id) else problemy).append(nazwa_g)    for dodatek in FLATPAK_GRY_DODATKI:                 # warstwy Vulkan dla gier z Flatpaka        flatpak_zainstaluj(dodatek)    if "Lutris" in zainstalowane:        # Lutris (Flatpak) widzi katalog gier i Steama z systemu        uruchom(["flatpak", "override", "--system", "net.lutris.Lutris",                 "--filesystem=~/Games", "--filesystem=~/.steam:ro", "--filesystem=xdg-data/Steam:ro"],                sprawdz=False, cicho=True)    k.uwaga("Gry spoza Steama: Epic, GOG i Amazon – otwórz Heroic Games Launcher i zaloguj się. "            "Rockstar, EA App, Ubisoft Connect, Battle.net – w Lutrisie kliknij „+” → "            "„Wyszukaj instalatory Lutris” i wpisz nazwę (np. Rockstar Games Launcher).")    if problemy:        raise Ostrzezenie("zainstalowano: " + (", ".join(zainstalowane) or "nic")                          + "; nie udało się: " + ", ".join(problemy))    return ", ".join(zainstalowane) + " + MangoHud, GameMode"def krok_czcionki(k: Kontekst) -> str:    oznacz_dodatek("czcionki")    wyniki = []    # Microsoft core fonts – instalator pobiera je ze strony projektu (licencja Microsoft EULA)    debconf_ustaw(["ttf-mscorefonts-installer msttcorefonts/accepted-mscorefonts-eula select true"])    apt_zainstaluj(["ttf-mscorefonts-installer"], ["cabextract", "fontconfig"] + CZCIONKI_PAKIETY)    if not SYMULACJA and not os.path.exists(os.path.join(CZCIONKI_MS_KATALOG, "arial.ttf")):        uruchom(["/usr/lib/msttcorefonts/update-ms-fonts"], sprawdz=False)   # druga próba pobrania    if SYMULACJA or os.path.exists(os.path.join(CZCIONKI_MS_KATALOG, "arial.ttf")):        wyniki.append("Microsoft")    else:        k.uwaga("Czcionek Microsoft nie udało się pobrać (serwer projektu niedostępny). Spróbuj "                "później: sudo /usr/lib/msttcorefonts/update-ms-fonts")    # Libre Barcode 39 (SIL OFL) – z repozytorium Google Fonts    pobrane = 0    for plik in KOD_KRESKOWY_PLIKI:        cel = os.path.join(KOD_KRESKOWY_KATALOG, os.path.basename(plik))        try:            pobierz_plik(KOD_KRESKOWY_URL + plik, cel)            pobrane += plik.endswith(".ttf")        except (urllib.error.URLError, OSError) as e:            log(f"Libre Barcode 39: {plik} – {e}")    if pobrane:        wyniki.append(f"Libre Barcode 39 ({pobrane} odmiany)")    else:        k.uwaga("Nie udało się pobrać czcionki Libre Barcode 39.")    uruchom(["fc-cache", "-f"], sprawdz=False, cicho=True)    wyniki.append("Carlito, Caladea, Liberation, Noto i inne")    if len(wyniki) < 3:        raise Ostrzezenie(", ".join(wyniki))    return ", ".join(wyniki)def krok_wine(k: Kontekst) -> str:    wyniki, problemy = [], []    apt_zainstaluj(["wine"], ["wine32:i386", "wine64", "libwine", "libwine:i386", "fonts-wine",                              "winetricks", "cabextract"])    wyniki.append(f"Wine {kandydat('wine')}")    if dostepny("playonlinux"):        apt_zainstaluj(["playonlinux"])        wyniki.append("PlayOnLinux")    elif flatpak_zainstaluj(FLATPAK_PLAYONLINUX):        wyniki.append("PlayOnLinux (Flatpak)")    else:        problemy.append("PlayOnLinux niedostępny ani w Debianie, ani na Flathub")    if not k.gry:                                       # Proton jest tylko do gier        if problemy:            raise Ostrzezenie(", ".join(wyniki) + "; problemy: " + "; ".join(problemy))        return ", ".join(wyniki)    if flatpak_zainstaluj(FLATPAK_PROTONUP):        wyniki.append("ProtonUp-Qt")    else:        problemy.append("ProtonUp-Qt nie został zainstalowany")    try:        wyniki.append(zainstaluj_ge_proton(k))    except (urllib.error.URLError, OSError, ValueError, BladPolecenia) as e:        problemy.append(f"GE-Proton: {e}")    k.uwaga("Proton w Steam: Steam → Ustawienia → Zgodność → włącz „Steam Play dla wszystkich "            "innych produktów” i wybierz Proton (Valve) albo GE-Proton.")    if problemy:        raise Ostrzezenie(", ".join(wyniki) + "; problemy: " + "; ".join(problemy))    return ", ".join(wyniki)# --- Krok: Docker i Whaler -------------------------------------------------------------------def krok_docker(k: Kontekst) -> str:    kodowa = os_release().get("VERSION_CODENAME", "trixie")    if not any("download.docker.com" in czytaj(p) for p in glob.glob("/etc/apt/sources.list.d/*")):        pobierz_plik(DOCKER_KLUCZ_URL, DOCKER_KLUCZ)        zapisz_plik("/etc/apt/sources.list.d/docker.sources", textwrap.dedent(f"""\            Types: deb            URIs: https://download.docker.com/linux/debian            Suites: {kodowa}            Components: stable            Architectures: {architektura()}            Signed-By: {DOCKER_KLUCZ}            """))        apt_update()    try:        apt_zainstaluj(["docker-ce", "docker-ce-cli", "containerd.io", "docker-buildx-plugin",                        "docker-compose-plugin"])        zrodlo = "repozytorium Docker"    except BladPolecenia as e:        log(f"Docker CE niedostępny ({e}) – instaluję docker.io z Debiana.")        apt_zainstaluj(["docker.io"], ["docker-compose", "docker-buildx"])        zrodlo = "repozytorium Debiana"    systemctl("enable", "--now", "docker.service")    for u in k.uzytkownicy:        uruchom(["usermod", "-aG", "docker", u.nazwa])    whaler = flatpak_zainstaluj(FLATPAK_WHALER)    if whaler:        uruchom(["flatpak", "override", "--system", "--filesystem=/run/docker.sock",                 FLATPAK_WHALER], sprawdz=False)    k.uwaga("Docker bez sudo i Whaler zadziałają po ponownym zalogowaniu (grupa docker).")    if not whaler:        raise Ostrzezenie(f"Docker z {zrodlo}; Whaler nie został zainstalowany")    return f"Docker z {zrodlo} + Whaler"# --- Krok: .deb w Discover --------------------------------------------------------------------def krok_discover_deb(k: Kontekst) -> str:    apt_zainstaluj(["plasma-discover"], ["plasma-discover-backend-packagekit", "packagekit"])    desktop = "org.kde.discover.desktop"    if not SYMULACJA and not os.path.exists(f"/usr/share/applications/{desktop}"):        desktop = znajdz_plik_desktop("discover") or desktop    ustaw_skojarzenia(k, {m: desktop for m in MIME_DEB})    return f"pliki .deb otwiera {desktop}"# --- Krok: tapeta ------------------------------------------------------------------------------def sprawdz_obraz(sciezka: str) -> None:    """Czy pobrany plik to obraz JPG/PNG (a nie np. strona błędu)."""    if SYMULACJA:        return    with open(sciezka, "rb") as f:        naglowek = f.read(8)    if not (naglowek.startswith(b"\xff\xd8\xff") or naglowek.startswith(b"\x89PNG")):        raise BladPolecenia(f"pobrany plik {sciezka} nie jest obrazem JPG/PNG")def wczytaj_grafike_z_argumentu(tekst: str) -> Dict[str, str]:    try:        dane = json.loads(tekst or "{}")    except ValueError:        return {}    return {n: a for n, a in dane.items() if isinstance(a, str) and n in GRAFIKA_Z_SERWERA.values()            and re.fullmatch(r"https?://\S{3,500}", a)} if isinstance(dane, dict) else {}def konwertuj_obraz(zrodlo: str, cel: str) -> int:    """(osobny proces) Zapis obrazu w formacie z rozszerzenia celu – np. tapeta PNG → JPG."""    os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")    from PyQt6.QtGui import QGuiApplication, QImage    _ = QGuiApplication([])    obraz = QImage(zrodlo)    return 0 if not obraz.isNull() and obraz.save(cel, None, 92) else 1def pobierz_obraz(url: str, cel: str) -> None:    """Pobiera obraz (JPG/PNG). Gdy format nie zgadza się z rozszerzeniem celu – konwertuje."""    tymczasowy = cel + ".pobrany"    pobierz_plik(url, tymczasowy)    sprawdz_obraz(tymczasowy)    if SYMULACJA:        return    with open(tymczasowy, "rb") as f:        png = f.read(4) == b"\x89PNG"    if png == cel.lower().endswith(".png"):        os.replace(tymczasowy, cel)        return    kod, _ = uruchom(["/usr/bin/python3", SKRYPT, "--konwertuj-obraz", tymczasowy, cel], sprawdz=False,                     srodowisko={"QT_QPA_PLATFORM": "offscreen"})    usun_plik(tymczasowy)    if kod != 0:        raise BladPolecenia(f"nie udało się przekształcić obrazu {url}")def krok_tapeta(k: Kontekst) -> str:    pobierz_obraz(k.grafika.get("tapeta") or TAPETA_URL, TAPETA_PLIK)    zapisz_plik(f"{TAPETA_KATALOG}/metadata.json", json.dumps({"KPlugin": {        "Id": "JablonskiKOMPUTERY", "Name": "Jabłoński KOMPUTERY",        "Authors": [{"Name": "Jabłoński KOMPUTERY"}]}}, ensure_ascii=False, indent=2) + "\n")    # sprzątanie po wersji 1.0 (tapetę u użytkowników ustawia teraz tryb sesji)    usun_plik("/usr/local/bin/jablonski-tapeta")    usun_plik("/etc/xdg/autostart/jablonski-tapeta.desktop")    # Ekran logowania SDDM – ta sama tapeta (motyw Breeze czyta theme.conf.user)    apt_zainstaluj([], ["sddm-theme-breeze", "kde-config-sddm"])    tlo = f"[General]\nbackground={TAPETA_PLIK}\ntype=image\n"    ustawione = []    for motyw in ("breeze", "debian-breeze"):        katalog = f"/usr/share/sddm/themes/{motyw}"        if os.path.isdir(katalog) or SYMULACJA:            zapisz_plik(f"{katalog}/theme.conf.user", tlo)            ustawione.append(motyw)    if os.path.isdir("/usr/share/sddm/themes/breeze") or SYMULACJA:        zapisz_plik("/etc/sddm.conf.d/20-jablonski-motyw.conf",                    "# Jabłoński KOMPUTERY – motyw ekranu logowania\n[Theme]\nCurrent=breeze\n")    if not ustawione:        raise Ostrzezenie("tapeta pobrana, ale nie znaleziono motywu Breeze dla ekranu logowania")    return ("z panelu" if k.grafika.get("tapeta") else "domyślna") + \        "; ustawiona na ekranie logowania (na pulpicie – w kroku „Pulpit”)"# --- Krok: program „J.K. - Nasza mocna strona” ------------------------------------------------KOD_APLIKACJI_JK = r'''#!/usr/bin/env python3# -*- coding: utf-8 -*-"""J.K. - Nasza mocna strona – okienko ze stroną Jabłoński KOMPUTERY.Zainstalowane przez: Optymalizator - Jabłoński KOMPUTERY - www.k.j.plAdres zawiera odcisk sprzętu (identyfikator licencji komputera), dzięki czemu serwis możepokazać konto i dane przygotowane dla tego klienta.Linki otwierane „w nowym oknie” trafiają do domyślnej przeglądarki."""import sysimport urllib.parseimport webbrowserTYTUL = "J.K. - Nasza mocna strona"ADRES = "https://jablonski-komputery.eu/?z=linux-app&devid={devid}"PLIK_URZADZENIA = "/etc/jablonski-komputery/urzadzenie"IKONA = "/usr/share/icons/hicolor/scalable/apps/jablonski-komputery.svg"def adres():    try:        with open(PLIK_URZADZENIA, encoding="utf-8") as plik:            devid = plik.read().strip()    except OSError:        devid = ""    return ADRES.format(devid=urllib.parse.quote(devid))def main():    try:        from PyQt6.QtCore import QUrl        from PyQt6.QtGui import QDesktopServices, QIcon        from PyQt6.QtWidgets import QApplication, QMainWindow        from PyQt6.QtWebEngineCore import QWebEnginePage, QWebEngineProfile        from PyQt6.QtWebEngineWidgets import QWebEngineView    except ImportError:        try:            from PyQt5.QtCore import QUrl            from PyQt5.QtGui import QDesktopServices, QIcon            from PyQt5.QtWidgets import QApplication, QMainWindow            from PyQt5.QtWebEngineWidgets import QWebEnginePage, QWebEngineProfile, QWebEngineView        except ImportError:            webbrowser.open(adres())       # brak Qt WebEngine – otwórz w przeglądarce            return 0    class Strona(QWebEnginePage):        def createWindow(self, _typ):            """Nowe okno (target=_blank) – przekazujemy adres do przeglądarki."""            posrednik = QWebEnginePage(self.profile(), self)            def otworz(url):                QDesktopServices.openUrl(url)                posrednik.deleteLater()            posrednik.urlChanged.connect(otworz)            return posrednik    app = QApplication(sys.argv)    app.setApplicationName("jk-nasza-mocna-strona")    app.setApplicationDisplayName(TYTUL)    app.setDesktopFileName("pl.jablonski_komputery.NaszaMocnaStrona")    app.setWindowIcon(QIcon(IKONA))    profil = QWebEngineProfile("jk-nasza-mocna-strona", app)   # trwałe ciasteczka i pamięć    profil.setHttpAcceptLanguage("pl-PL,pl;q=0.9,en;q=0.5")    okno = QMainWindow()    okno.setWindowTitle(TYTUL)    okno.resize(1200, 820)    widok = QWebEngineView(okno)    strona = Strona(profil, widok)    widok.setPage(strona)    widok.titleChanged.connect(lambda t: okno.setWindowTitle(f"{TYTUL} – {t}" if t else TYTUL))    widok.load(QUrl(adres()))    okno.setCentralWidget(widok)    okno.show()    kod = app.exec() if hasattr(app, "exec") else app.exec_()    strona.setParent(None)      # strona musi zniknąć przed profilem    del strona    return kodif __name__ == "__main__":    sys.exit(main())'''IKONA_JK_SVG = """\<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">  <defs>    <linearGradient id="g" x1="0" y1="0" x2="1" y2="1">      <stop offset="0" stop-color="#e65100"/>      <stop offset="1" stop-color="#ffa000"/>    </linearGradient>  </defs>  <rect x="2" y="2" width="60" height="60" rx="14" fill="url(#g)"/>  <circle cx="50" cy="14" r="5" fill="#ffffff" fill-opacity="0.25"/>  <text x="32" y="41" font-family="DejaVu Sans, Noto Sans, sans-serif" font-size="22"        font-weight="bold" fill="#ffffff" text-anchor="middle">J.K.</text></svg>"""DESKTOP_JK = f"""\[Desktop Entry]Type=ApplicationVersion=1.0Name={JK_NAZWA}GenericName=Jabłoński KOMPUTERYComment=Pomoc i informacje dla Twojego komputeraExec=/usr/bin/python3 {JK_SKRYPT}Icon=jablonski-komputeryTerminal=falseCategories=Network;Utility;StartupWMClass=jk-nasza-mocna-strona"""def krok_aplikacja_jk(k: Kontekst) -> str:    if not apt_zainstaluj([], ["python3-pyqt6", "python3-pyqt6.qtwebengine"]):        apt_zainstaluj([], ["python3-pyqt5", "python3-pyqt5.qtwebengine"])    zapisz_plik(JK_SKRYPT, KOD_APLIKACJI_JK, 0o755)    zapisz_plik(JK_IKONA, IKONA_JK_SVG)    zapisz_plik(f"/usr/share/applications/{JK_DESKTOP}", DESKTOP_JK)    uruchom(["gtk-update-icon-cache", "-q", "/usr/share/icons/hicolor"], sprawdz=False, cicho=True)    devid = zapisz_odcisk_sprzetu()    return f"w menu (skrót na Pulpicie – krok „Pulpit”); adres: {JK_URL.format(devid=devid)}"def zapisz_odcisk_sprzetu() -> str:    """Odcisk sprzętu do pliku czytelnego dla każdego – program „Nasza mocna strona” wstawia    go do adresu (devid). Odświeżany też przy każdym starcie (usługa zgłoszenia uruchomienia)."""    devid, _ = identyfikator_sprzetu()    if czytaj(PLIK_URZADZENIA).strip() != devid:        zapisz_plik(PLIK_URZADZENIA, devid + "\n", 0o644)    return devid# --- Krok: zasilanie (bez wygaszania i usypiania) ----------------------------------------CELE_USYPIANIA = ["sleep.target", "suspend.target", "hibernate.target", "hybrid-sleep.target",                  "suspend-then-hibernate.target"]def krok_zasilanie(k: Kontekst) -> str:    # 1) systemd: usypianie i hibernacja całkowicie niedostępne (znikają też z menu)    systemctl("mask", *CELE_USYPIANIA)    zapisz_plik("/etc/systemd/sleep.conf.d/50-jablonski-bez-usypiania.conf", textwrap.dedent("""\        # Jabłoński KOMPUTERY – bez usypiania i hibernacji        [Sleep]        AllowSuspend=no        AllowHibernation=no        AllowSuspendThenHibernate=no        AllowHybridSleep=no        """))    # 2) logind: przyciski uśpienia, klapa laptopa i bezczynność nic nie robią    zapisz_plik("/etc/systemd/logind.conf.d/50-jablonski-bez-usypiania.conf", textwrap.dedent("""\        # Jabłoński KOMPUTERY – bez usypiania (zadziała po restarcie)        [Login]        HandleSuspendKey=ignore        HandleHibernateKey=ignore        HandleLidSwitch=ignore        HandleLidSwitchExternalPower=ignore        HandleLidSwitchDocked=ignore        IdleAction=ignore        """))    # 3) KDE PowerDevil (Plasma 6), każdy profil (zasilacz, bateria, słaba bateria):    #    przyciemnienie po 15 min, ekran nigdy się nie wyłącza, bezczynność – nic nie rób,    #    „Przełącz profil zasilania” – pozostaw bez zmian (pusty), bez wymuszania oszczędzania    ustawienia = {}    for profil in ("AC", "Battery", "LowBattery"):        ustawienia[f"{profil}][Display"] = {"DimDisplayWhenIdle": "true",                                            "DimDisplayIdleTimeoutSec": str(PRZYCIEMNIJ_PO_SEKUNDACH),                                            "TurnOffDisplayWhenIdle": "false"}        ustawienia[f"{profil}][SuspendAndShutdown"] = {"AutoSuspendAction": "0", "LidAction": "0"}        ustawienia[f"{profil}][Performance"] = {"PowerProfile": ""}    ustaw_kde(k, "powerdevilrc", ustawienia)    # 4) Profil zasilania: wysoka wydajność (power-profiles-daemon zapamiętuje go po restarcie)    apt_zainstaluj([], ["power-profiles-daemon"])    _, profile = uruchom(["powerprofilesctl", "list"], sprawdz=False, cicho=True, tylko_odczyt=True)    if "performance" in profile or SYMULACJA:        uruchom(["powerprofilesctl", "set", "performance"], sprawdz=False)        wydajnosc = "wysoka wydajność"    else:        uruchom(["powerprofilesctl", "set", "balanced"], sprawdz=False, cicho=True)        wydajnosc = "zrównoważony (ten komputer nie ma trybu wysokiej wydajności)"    odswiez_ustawienia_sesji(k)    return (f"przyciemnianie po {PRZYCIEMNIJ_PO_SEKUNDACH // 60} min, ekran nie gaśnie; "            f"bez usypiania i hibernacji; profil: {wydajnosc}")# --- Krok: ustawienia systemowe KDE ----------------------------------------------------------def krok_ustawienia_kde(k: Kontekst) -> str:    ustaw_kde(k, "kdeglobals", {"KDE": {"AnimationDurationFactor": SZYBKOSC_ANIMACJI}})    # Posiedzenie pulpitu: bez pytania o potwierdzenie, start z pustym posiedzeniem    ustaw_kde(k, "ksmserverrc", {"General": {"confirmLogout": "false", "loginMode": "emptySession"}})    # Sprawdzanie pisowni (Sonnet): włączone, polski słownik    ustaw_kde(k, "KDE/Sonnet.conf", {"General": {        "defaultLanguage": SLOWNIK_PISOWNI, "preferredLanguages": SLOWNIK_PISOWNI,        "checkerEnabledByDefault": "true", "backgroundCheckerEnabled": "true",        "autodetectLanguage": "false"}})    # Informacja zwrotna dla KDE: wyłączona (Plasma i Discover oraz wyłącznik globalny)    ustaw_kde(k, "PlasmaUserFeedback", {"Global": {"FeedbackLevel": "0"}})    ustaw_kde(k, "KDE/UserFeedback.conf", {"UserFeedback": {"Enabled": "false"}})    # Blokada ekranu: automatycznie nigdy, zaznaczone „Blokuj po wybudzeniu”    ustaw_kde(k, "kscreenlockerrc", {"Daemon": {"Autolock": "false", "LockOnResume": "true"}})    # Dolphin: start w katalogu domowym, widok zapamiętywany osobno dla każdego katalogu,    # archiwa (zip, tar…) otwierane jak katalogi    ustaw_kde(k, "dolphinrc", {"General": {"RememberOpenedTabs": "false", "GlobalViewProps": "false",                                           "BrowseThroughArchives": "true"}})    # przenoszenie do kosza i usuwanie bez pytania „Czy na pewno?” (okna potwierdzeń KIO)    ustaw_kde(k, "kiorc", {"Confirmations": {"ConfirmTrash": "false", "ConfirmDelete": "false"}})    # Domyślne programy → Mapa: Mapy Google    zapisz_plik(MAPY_SKRYPT, SKRYPT_MAPY, 0o755)    zapisz_plik(MAPY_DESKTOP, DESKTOP_MAPY)    ustaw_skojarzenia(k, {"x-scheme-handler/geo": os.path.basename(MAPY_DESKTOP)})    # Skróty klawiszowe znane z Windows (działają od następnego zalogowania)    ustaw_kde(k, "kglobalshortcutsrc", SKROTY_WINDOWS)    odswiez_ustawienia_sesji(k)    return ("animacje szybkie, wyłączanie bez pytania, pusta sesja po zalogowaniu, "            "polski słownik, telemetria wyłączona, blokada tylko po wybudzeniu, mapy Google, Dolphin, "            "skróty klawiszowe jak w Windows")# Skróty klawiszowe jak w Windows. Zapis jak w KDE Plasma 6 (~/.config/kglobalshortcutsrc):# grupy [services][plik.desktop] – kilka skrótów rozdzielonych „\t”. Domyślne skróty KDE zostają.# Ctrl+Alt+Del otwiera Menedżer zadań (w KDE domyślnie wylogowuje – a przy wyłączonym pytaniu# „Czy na pewno?” osoba z nawykami z Windows mogłaby niechcący zamknąć wszystkie programy).SKROTY_WINDOWS = {    "services][org.kde.plasma-systemmonitor.desktop": {"_launch": "Ctrl+Esc\\tCtrl+Shift+Esc\\tCtrl+Alt+Del"},    "ksmserver": {"Log Out": "none,Ctrl+Alt+Del,Show Logout Prompt"},    "services][org.kde.spectacle.desktop": {"RectangularRegionScreenShot": "Meta+Shift+Print\\tMeta+Shift+S"},    "services][org.kde.krunner.desktop": {"_launch": "Alt+Space\\tAlt+F2\\tSearch\\tMeta+R"},    "services][systemsettings.desktop": {"_launch": "Meta+I"},    "services][org.kde.dolphin.desktop": {"_launch": "Meta+E"},}SKRYPT_MAPY = """#!/bin/sh# Jabłoński KOMPUTERY: adres geo:szer,dł[?q=...] → Mapy Google w domyślnej przeglądarceadres="${1#geo:}"case "$adres" in  *q=*) zapytanie="${adres#*q=}"; zapytanie="${zapytanie%%&*}" ;;  *)    zapytanie="${adres%%[?;]*}" ;;esac[ "$zapytanie" = "0,0" ] && zapytanie=""exec xdg-open "https://www.google.com/maps/search/?api=1&query=${zapytanie}""""DESKTOP_MAPY = f"""[Desktop Entry]Type=ApplicationName=Mapy GoogleComment=Otwiera lokalizacje w Mapach Google w przeglądarceExec={MAPY_SKRYPT} %uIcon=map-globeMimeType=x-scheme-handler/geo;NoDisplay=true"""# --- Urządzenia Logitech ----------------------------------------------------------------------def wykryj_logitech() -> List[str]:    """Podłączone urządzenia Logitech z listy LOGITECH (po identyfikatorach USB)."""    produkty = set()    for katalog in glob.glob("/sys/bus/usb/devices/*"):        if czytaj(os.path.join(katalog, "idVendor")).strip().lower() == "046d":            produkty.add(czytaj(os.path.join(katalog, "idProduct")).strip().lower())    return [id_ for id_, (_, _, ids) in LOGITECH.items() if produkty & ids]def wczytaj_podswietlenie() -> Dict[str, str]:    try:        dane = json.loads(czytaj(PODSWIETLENIE_PLIK) or "{}")    except ValueError:        dane = {}    kolor = str(dane.get("kolor", "")).lower().lstrip("#")    efekt = str(dane.get("efekt", ""))    return {"kolor": kolor if re.fullmatch(r"[0-9a-f]{6}", kolor) else PODSWIETLENIE_DOMYSLNE["kolor"],            "efekt": efekt if efekt in PODSWIETLENIE_EFEKTY else PODSWIETLENIE_DOMYSLNE["efekt"]}def _polecenie_cicho(polecenie: List[str]) -> Tuple[int, str]:    """Polecenie bez dziennika programu (okno podświetlenia i usługa startowa)."""    if SYMULACJA:        log("[symulacja] " + " ".join(polecenie))        return 0, ""    try:        w = subprocess.run(polecenie, capture_output=True, text=True, timeout=30)        return w.returncode, (w.stdout + w.stderr).strip()    except (OSError, subprocess.TimeoutExpired) as e:        return 1, str(e)def zastosuj_podswietlenie(ustawienia: Dict[str, str],                           urzadzenia: Optional[List[str]] = None) -> List[str]:    """Ustawia kolor/efekt na G213 (g810-led) i G102 (ratbagctl). Zwraca opis wyników."""    kolor, efekt = ustawienia["kolor"], ustawienia["efekt"]    urzadzenia = wykryj_logitech() if urzadzenia is None else urzadzenia    wyniki = []    if "g213" in urzadzenia:        program = shutil.which("g213-led") or shutil.which("g810-led") or "g213-led"        polecenie = {"staly": [program, "-a", kolor],                     "oddychanie": [program, "-fx", "breathing", "all", kolor, "0a"],                     "tecza": [program, "-fx", "cycle", "all", "0a"]}[efekt]        kod, wyjscie = _polecenie_cicho(polecenie)        wyniki.append("G213: " + ("ustawiono" if kod == 0 else f"błąd ({wyjscie[-120:] or kod})"))    if "g102" in urzadzenia:        kod, lista = _polecenie_cicho(["ratbagctl", "list"])        mysz = next((l.split(":")[0].strip() for l in lista.splitlines()                     if re.search(r"G10[23]|G203", l)), None)        if SYMULACJA:            mysz = mysz or "mysz"        if not mysz:            wyniki.append("G102: nie znaleziono myszy (ratbagd)")        else:            tryb = {"staly": "on", "oddychanie": "breathing", "tecza": "cycle"}[efekt]            bledy = 0            for led in ("0", "1", "2"):                 # Lightsync ma 1–3 strefy                kod, _ = _polecenie_cicho(["ratbagctl", mysz, "led", led, "set", "mode", tryb])                if kod != 0:                    bledy += led == "0"                    break                if tryb != "cycle":                    _polecenie_cicho(["ratbagctl", mysz, "led", led, "set", "color", kolor])                if tryb != "on":                    _polecenie_cicho(["ratbagctl", mysz, "led", led, "set", "duration", "3000"])            wyniki.append("G102: " + ("ustawiono (zapisane w myszy)" if not bledy else "błąd ratbagctl"))    return wyniki or ["nie wykryto G213 ani G102"]def uruchom_podswietlenie_start() -> int:    """Usługa systemowa przy starcie (przed logowaniem): przywraca kolor G213 i G102."""    for _ in range(15):                                 # urządzenia USB mogą pojawić się później        if set(wykryj_logitech()) & {"g213", "g102"}:            break        time.sleep(1)    for wynik in zastosuj_podswietlenie(wczytaj_podswietlenie()):        print(wynik)    return 0USLUGA_PODSWIETLENIA_TRESC = f"""[Unit]Description=Podświetlenie klawiatury i myszy Logitech (Jabłoński KOMPUTERY)After=systemd-udev-settle.service dbus.serviceWants=systemd-udev-settle.service[Service]Type=oneshotExecStart=/usr/bin/python3 {SKRYPT_SYSTEMOWY} --podswietlenie-start[Install]WantedBy=multi-user.target"""REGULY_LOGITECH_TRESC = f"""# Jabłoński KOMPUTERY – urządzenia Logitech# G213: dostęp dla zalogowanego użytkownika (okno „{PODSWIETLENIE_NAZWA}”) i kolor po podłączeniuSUBSYSTEM=="hidraw", ATTRS{{idVendor}}=="046d", ATTRS{{idProduct}}=="c336", TAG+="uaccess"SUBSYSTEM=="usb", ATTRS{{idVendor}}=="046d", ATTRS{{idProduct}}=="c336", TAG+="uaccess"ACTION=="add", SUBSYSTEM=="usb", ENV{{DEVTYPE}}=="usb_device", ATTR{{idVendor}}=="046d", ATTR{{idProduct}}=="c336", TAG+="systemd", ENV{{SYSTEMD_WANTS}}+="{USLUGA_PODSWIETLENIA}"# G19 / G19s: klawisze i wyświetlacz (g19daemon)SUBSYSTEM=="usb", ATTRS{{idVendor}}=="046d", ATTRS{{idProduct}}=="c228", GROUP="input", MODE="0660", TAG+="uaccess"SUBSYSTEM=="usb", ATTRS{{idVendor}}=="046d", ATTRS{{idProduct}}=="c229", GROUP="input", MODE="0660", TAG+="uaccess""""DESKTOP_PODSWIETLENIA = f"""[Desktop Entry]Type=ApplicationName={PODSWIETLENIE_NAZWA}GenericName=Kolor klawiatury i myszyComment=Kolor i efekt podświetlenia Logitech G213 i G102 – ustawia się też przy starcie komputeraExec=/usr/bin/python3 {SKRYPT_SYSTEMOWY} --podswietlenieIcon=preferences-desktop-colorCategories=Settings;HardwareSettings;Keywords=logitech;g213;g102;rgb;podświetlenie;kolor;klawiatura;mysz;"""DESKTOP_G19 = """[Desktop Entry]Type=ApplicationName=G19 – klawisze i wyświetlaczComment=Obsługa klawiatury Logitech G19/G19s (Jabłoński KOMPUTERY)Exec=g19daemonIcon=g19daemonX-GNOME-Autostart-enabled=true"""def _zainstaluj_g19(k: Kontekst) -> str:    potrzebne = ["git", "build-essential", "cmake", "pkgconf", "qt6-base-dev", "libusb-1.0-0-dev",                 "libpulse-dev", "qt6-tools-dev"]    nowe = [p for p in potrzebne if not zainstalowany(p)]   # te usuniemy razem z G19s    oznacz_dodatek("g19s", g19_pakiety=sorted(set(wczytaj_dodatki().get("g19_pakiety", []) + nowe)))    apt_zainstaluj(potrzebne[:-1], potrzebne[-1:])    zrodla = os.path.join(k.katalog_tmp, "g19daemon")    uruchom(["git", "clone", "--depth", "1", G19_REPOZYTORIUM, zrodla])    budowa = os.path.join(zrodla, "build")    uruchom(["cmake", "-S", zrodla, "-B", budowa, "-DCMAKE_INSTALL_PREFIX=/usr",             "-DCMAKE_BUILD_TYPE=Release"])    uruchom(["cmake", "--build", budowa, "-j", str(os.cpu_count() or 2)])    uruchom(["cmake", "--install", budowa])    manifest = os.path.join(budowa, "install_manifest.txt")   # lista zainstalowanych plików    if os.path.exists(manifest):        kopiuj_plik(manifest, G19_PLIKI)    zapisz_plik(G19_AUTOSTART, DESKTOP_G19)    for u in k.uzytkownicy:                             # dostęp do klawiszy G        uruchom(["usermod", "-aG", "input", u.nazwa], sprawdz=False)    return "g19daemon (z GitHuba)"def krok_logitech(k: Kontekst) -> str:    if not k.logitech:        raise Pominiety("nie wybrano urządzeń Logitech")    for urzadzenie in k.logitech:        if urzadzenie != "g19s":                        # G19s zapisuje _zainstaluj_g19 (z pakietami do budowania)            oznacz_dodatek(urzadzenie)    wyniki = []    zapisz_plik(REGULY_LOGITECH, REGULY_LOGITECH_TRESC)    uruchom(["udevadm", "control", "--reload-rules"], sprawdz=False)    if {"g213", "g102"} & set(k.logitech):        if SKRYPT != SKRYPT_SYSTEMOWY:                  # usługa i okno korzystają z kopii programu            kopiuj_plik(SKRYPT, SKRYPT_SYSTEMOWY, 0o755)        if "g213" in k.logitech:            apt_zainstaluj(["g810-led"])        if "g102" in k.logitech:            apt_zainstaluj(["ratbagd"], ["piper"])            systemctl("enable", "--now", "ratbagd")        if not os.path.exists(PODSWIETLENIE_PLIK):            zapisz_plik(PODSWIETLENIE_PLIK, json.dumps(PODSWIETLENIE_DOMYSLNE) + "\n", 0o666)        elif not SYMULACJA:            os.chmod(PODSWIETLENIE_PLIK, 0o666)          # okno zapisuje wybór jako użytkownik        zapisz_plik(PODSWIETLENIE_DESKTOP, DESKTOP_PODSWIETLENIA)        zapisz_plik(f"/etc/systemd/system/{USLUGA_PODSWIETLENIA}", USLUGA_PODSWIETLENIA_TRESC)        systemctl("daemon-reload")        systemctl("enable", USLUGA_PODSWIETLENIA)        uruchom(["udevadm", "trigger", "--subsystem-match=usb", "--attr-match=idVendor=046d"],                sprawdz=False)        wyniki += zastosuj_podswietlenie(wczytaj_podswietlenie(),                                         [u for u in k.logitech if u in ("g213", "g102")])    if "g19s" in k.logitech:        try:            wyniki.append("G19s: " + _zainstaluj_g19(k))        except BladPolecenia as e:            k.uwaga(f"Nie udało się zbudować g19daemon (Logitech G19s): {e}")            wyniki.append("G19s: błąd budowania")    return "; ".join(wyniki)# --- Dodatki: zapis, co zainstalowano, i sprzątanie --------------------------------------------def wczytaj_dodatki() -> Dict[str, list]:    """Co z opcji zainstalował program. Komputer skonfigurowany starszą wersją (bez tego pliku)    – rozpoznajemy po zainstalowanych programach."""    try:        dane = json.loads(czytaj(PLIK_DODATKOW) or "null")    except ValueError:        dane = None    if not isinstance(dane, dict):        dane = {"zainstalowane": []}        if os.path.exists(SKRYPT_SYSTEMOWY):            # wcześniej optymalizowany starszą wersją            wykryte = {                "czcionki": zainstalowany("ttf-mscorefonts-installer"),                "multimedia": zainstalowany("libavcodec-extra") or zainstalowany("kdenlive")                or zainstalowany("audacity"),                "g213": zainstalowany("g810-led"),                "g102": zainstalowany("piper"),                "g19s": bool(shutil.which("g19daemon")),                "gry": zainstalowany("steam-installer") or flatpak_zainstalowany("net.lutris.Lutris"),                "dell": os.path.exists(f"/etc/systemd/system/{USLUGA_DELL}"),                "nvidia_rtx": os.path.exists(NVUNLOCK_GRUB),            }            dane["zainstalowane"] = [d for d, jest in wykryte.items() if jest]    dane["zainstalowane"] = [d for d in DODATKI if d in dane.get("zainstalowane", [])]    return danedef oznacz_dodatek(nazwa: str, zainstalowany_: bool = True, **dodatkowe) -> None:    dane = wczytaj_dodatki()    lista = set(dane["zainstalowane"])    (lista.add if zainstalowany_ else lista.discard)(nazwa)    dane["zainstalowane"] = [d for d in DODATKI if d in lista]    dane.update(dodatkowe)    zapisz_plik(PLIK_DODATKOW, json.dumps(dane, ensure_ascii=False, indent=1) + "\n")def dodatki_do_usuniecia(opcje, gry: bool, logitech, nvidia_rtx: bool = False) -> List[str]:    """Zainstalowane wcześniej dodatki, których klient teraz nie wybrał albo nie ma w pakiecie."""    potrzebne = {o for o in ("czcionki", "multimedia", "dell") if o in opcje}    if nvidia_rtx and "nvidia_rtx" in opcje:        potrzebne.add("nvidia_rtx")    potrzebne |= {u for u in logitech if u in opcje}    if gry and "gry" in opcje:        potrzebne.add("gry")    return [d for d in wczytaj_dodatki()["zainstalowane"] if d not in potrzebne]def _purge(pakiety: List[str]) -> None:    obecne = [p for p in pakiety if zainstalowany(p)]    if obecne:        uruchom(["apt-get", "purge", *APT_OPCJE, *obecne], sprawdz=False)def _na_automatyczne(pakiety: List[str]) -> None:    """Pakiety, które mogą być potrzebne innym – zostaną usunięte tylko, gdy nic ich nie używa."""    obecne = [p for p in pakiety if zainstalowany(p)]    if obecne:        uruchom(["apt-mark", "auto", *obecne], sprawdz=False, cicho=True)def _flatpak_usun(identyfikatory: List[str]) -> None:    for app_id in identyfikatory:        if flatpak_zainstalowany(app_id) or SYMULACJA:            uruchom(["flatpak", "uninstall", "-y", "--noninteractive", "--system", "--delete-data",                     app_id], sprawdz=False)def _usun_u_uzytkownikow(k: Kontekst, sciezki: List[str]) -> None:    for u in k.uzytkownicy:        for sciezka in sciezki:            for pelna in glob.glob(u.sciezka(sciezka)) or [u.sciezka(sciezka)]:                usun_plik(pelna)def _usun_skroty_gier(k: Kontekst) -> None:    """Skróty gier, które Steam/Lutris/Heroic dodały do menu i na Pulpit."""    for u in k.uzytkownicy:        for katalog in (".local/share/applications", "Pulpit", "Desktop"):            for plik in glob.glob(u.sciezka(katalog, "*.desktop")):                if re.search(r"steam://rungameid|lutris:rungame|heroic://launch", czytaj(plik)):                    usun_plik(plik)def _sprzataj_podswietlenie(k: Kontekst) -> None:    if {"g213", "g102"} & set(k.logitech):        return                                          # inne urządzenie dalej korzysta z usługi    systemctl("disable", USLUGA_PODSWIETLENIA)    for plik in (f"/etc/systemd/system/{USLUGA_PODSWIETLENIA}", PODSWIETLENIE_DESKTOP,                 PODSWIETLENIE_PLIK):        usun_plik(plik)    systemctl("daemon-reload")def usun_gry(k: Kontekst) -> None:    _purge(["steam-installer", "steam-launcher", "steam", "steam-libs-amd64", "steam-libs-i386"])    _na_automatyczne(["steam-devices", "gamemode", "mangohud", "mangohud:i386", "vulkan-tools"])    _flatpak_usun([app_id for app_id, _ in FLATPAK_GRY] + [FLATPAK_PROTONUP] + FLATPAK_GRY_DODATKI)    usun_plik(KATALOG_PROTON)    _usun_skroty_gier(k)    _usun_u_uzytkownikow(k, [".steam", ".steampath", ".steampid", ".local/share/Steam",                             ".local/share/icons/hicolor/*/apps/steam_icon_*.png",                             ".var/app/net.lutris.Lutris", ".var/app/com.heroicgameslauncher.hgl",                             f".var/app/{FLATPAK_PROTONUP}", "Games/Heroic", ".config/MangoHud"])def usun_multimedia(k: Kontekst) -> None:    _purge(["kdenlive", "audacity", "libdvd-pkg", "libdvdcss2"])    _na_automatyczne([p for p in KODEKI_WYMAGANE + KODEKI_DODATKOWE if p not in KODEKI_ZOSTAJA]                     + ["frei0r-plugins", "mediainfo"])    _flatpak_usun(FLATPAK_KODEKI)    _usun_u_uzytkownikow(k, [".config/kdenliverc", ".config/kdenlive-layoutsrc",                             ".local/share/kdenlive", ".cache/kdenlive",                             ".config/audacity", ".local/share/audacity", ".cache/audacity",                             ".audacity-data"])def usun_czcionki(k: Kontekst) -> None:    _purge(["ttf-mscorefonts-installer"])    _na_automatyczne(CZCIONKI_PAKIETY)    usun_plik(KOD_KRESKOWY_KATALOG)    uruchom(["fc-cache", "-f"], sprawdz=False, cicho=True)def usun_g213(k: Kontekst) -> None:    _purge(["g810-led"])    _sprzataj_podswietlenie(k)def usun_g102(k: Kontekst) -> None:    _purge(["piper", "ratbagd"])    _sprzataj_podswietlenie(k)def usun_g19s(k: Kontekst) -> None:    pliki = [l.strip() for l in czytaj(G19_PLIKI).splitlines() if l.strip()] or [        "/usr/bin/g19daemon", "/usr/lib/g19daemon", "/usr/share/applications/g19daemon.desktop",        "/usr/share/icons/g19daemon.png", "/etc/udev/rules.d/80-hid-g19.rules"]    for plik in pliki:        usun_plik(plik)    usun_plik("/usr/lib/g19daemon")    usun_plik(G19_AUTOSTART)    usun_plik(G19_PLIKI)    _na_automatyczne(wczytaj_dodatki().get("g19_pakiety", []))    _usun_u_uzytkownikow(k, [".config/G19Daemon"])USUWANIE_DODATKOW = {"czcionki": usun_czcionki, "multimedia": usun_multimedia, "g213": usun_g213,                     "g102": usun_g102, "g19s": usun_g19s, "gry": usun_gry,                     "dell": lambda k: usun_dell(k), "nvidia_rtx": lambda k: usun_nvidia_rtx(k)}def krok_sprzatanie(k: Kontekst) -> str:    do_usuniecia = k.flagi.get("do_usuniecia", [])    if not do_usuniecia:        raise Pominiety("nic do usunięcia")    usuniete, problemy = [], []    for dodatek in do_usuniecia:        log(f"Usuwanie: {DODATKI[dodatek]}")        try:            USUWANIE_DODATKOW[dodatek](k)            oznacz_dodatek(dodatek, False)            usuniete.append(DODATKI[dodatek].split(" – ")[0].split(" (")[0])        except (BladPolecenia, OSError) as e:            problemy.append(f"{dodatek}: {e}")    if not k.logitech:        usun_plik(REGULY_LOGITECH)    uruchom(["apt-get", "autoremove", "--purge", *APT_OPCJE], sprawdz=False)    if shutil.which("flatpak"):        uruchom(["flatpak", "uninstall", "--unused", "-y", "--noninteractive", "--system"],                sprawdz=False)    if problemy:        raise Ostrzezenie("usunięto: " + (", ".join(usuniete) or "nic") + "; problemy: "                          + "; ".join(problemy))    return "usunięto: " + ", ".join(usuniete)# --- DELL Unlock Pin ID --------------------------------------------------------------------------def jest_dell() -> bool:    return czytaj("/sys/class/dmi/id/sys_vendor").strip().lower().startswith("dell")def _zaladuj_msr() -> None:    """Moduł jądra msr (dostęp do rejestrów procesora /dev/cpu/*/msr)."""    if glob.glob("/dev/cpu/[0-9]*/msr"):        return    try:        subprocess.run([shutil.which("modprobe") or "/usr/sbin/modprobe", "msr"],                       capture_output=True, timeout=20)    except (OSError, subprocess.SubprocessError):        passdef _msr_pliki() -> List[str]:    return sorted(glob.glob("/dev/cpu/[0-9]*/msr"), key=lambda p: int(p.split("/")[3]))def msr_odczyt(plik: str, adres: int) -> Optional[int]:    try:        fd = os.open(plik, os.O_RDONLY)        try:            return int.from_bytes(os.pread(fd, 8, adres), "little")        finally:            os.close(fd)    except OSError:        return Nonedef msr_zapis(plik: str, adres: int, wartosc: int) -> bool:    try:        fd = os.open(plik, os.O_WRONLY)        try:            return os.pwrite(fd, wartosc.to_bytes(8, "little"), adres) == 8        finally:            os.close(fd)    except OSError:        return Falsedef blokada_jadra() -> bool:    """Secure Boot włącza „lockdown” jądra – wtedy zapis do MSR jest zablokowany."""    return bool(re.search(r"\[(integrity|confidentiality)\]", czytaj("/sys/kernel/security/lockdown")))def problem_pin_id() -> Tuple[bool, str]:    """Czy procesor jest dławiony zewnętrznym sygnałem PROCHOT (typowe przy nierozpoznanym    zasilaczu Dell). Działa jako root, tylko na procesorach Intel."""    if "GenuineIntel" not in czytaj("/proc/cpuinfo"):        return False, "procesor nie Intel"    _zaladuj_msr()    pliki = _msr_pliki()    if not pliki:        return False, "brak dostępu do rejestrów procesora (moduł msr)"    term = msr_odczyt(pliki[0], MSR_PAKIET_TERM) or 0    limity = msr_odczyt(pliki[0], MSR_POWODY_LIMITU) or 0    zasilanie = msr_odczyt(pliki[0], MSR_POWER_CTL)    prochot = bool(term & 0b1100) or bool(limity & (1 | 1 << 16))    if zasilanie is not None and not zasilanie & 1:        return True, "spowalnianie już wyłączone"    return prochot, ("procesor dławiony sygnałem PROCHOT (zasilacz nierozpoznany)" if prochot                     else "zasilacz rozpoznany, procesor nie jest dławiony")def ustaw_bd_prochot(wlaczony: bool) -> Tuple[int, int]:    """Bit BD PROCHOT na wszystkich rdzeniach. Zwraca (zmienione, błędy)."""    _zaladuj_msr()    zmienione = bledy = 0    for plik in _msr_pliki():        wartosc = msr_odczyt(plik, MSR_POWER_CTL)        if wartosc is None:            bledy += 1            continue        nowa = wartosc | 1 if wlaczony else wartosc & ~1        if nowa != wartosc:            if msr_zapis(plik, MSR_POWER_CTL, nowa):                zmienione += 1            else:                bledy += 1    return zmienione, bledydef uruchom_dell_pin_id() -> int:    """Usługa przy starcie (i po wybudzeniu): wyłącza spowalnianie przez zasilacz Dell."""    if not jest_dell():        print("To nie jest komputer Dell – nic nie robię.")        return 0    if blokada_jadra():        print("Secure Boot (lockdown jądra) blokuje zmianę – wyłącz Secure Boot w BIOS.")        return 0    zmienione, bledy = ustaw_bd_prochot(False)    print(f"BD PROCHOT wyłączony (rdzeni: {zmienione}, błędów: {bledy}).")    return 0USLUGA_DELL_TRESC = f"""[Unit]Description=DELL Unlock Pin ID – pełna wydajność przy nierozpoznanym zasilaczu (Jabłoński KOMPUTERY)After=systemd-modules-load.serviceBefore=display-manager.service[Service]Type=oneshotExecStart=/usr/bin/python3 {SKRYPT_SYSTEMOWY} --dell-pin-id[Install]WantedBy=multi-user.target"""HAK_USYPIANIA_DELL_TRESC = f"""#!/bin/sh# Jabłoński KOMPUTERY – po wybudzeniu procesor znów reaguje na PROCHOT; wyłączamy ponownie[ "$1" = "post" ] && /usr/bin/python3 {SKRYPT_SYSTEMOWY} --dell-pin-id >/dev/null 2>&1exit 0"""def krok_dell(k: Kontekst) -> str:    if not jest_dell():        raise Pominiety("to nie jest komputer Dell")    if SYMULACJA:        problem, opis = True, "symulacja"    else:        problem, opis = problem_pin_id()    if not problem and "dell" not in wczytaj_dodatki()["zainstalowane"]:        raise Pominiety(opis)                          # zasilacz w porządku – nic nie zmieniamy    oznacz_dodatek("dell")    if SKRYPT != SKRYPT_SYSTEMOWY:        kopiuj_plik(SKRYPT, SKRYPT_SYSTEMOWY, 0o755)    zapisz_plik(MODULY_DELL, "msr\n")    zapisz_plik(OPCJE_MSR_DELL, "# zapis bitu BD PROCHOT bez ostrzeżeń w dzienniku jądra\n"                                "options msr allow_writes=on\n")    zapisz_plik(f"/etc/systemd/system/{USLUGA_DELL}", USLUGA_DELL_TRESC)    zapisz_plik(HAK_USYPIANIA_DELL, HAK_USYPIANIA_DELL_TRESC, 0o755)    systemctl("daemon-reload")    systemctl("enable", USLUGA_DELL)    if not SYMULACJA and blokada_jadra():        k.uwaga("DELL Unlock Pin ID: Secure Boot blokuje wyłączenie spowalniania procesora. "                "Wyłącz Secure Boot w BIOS (F2 przy starcie) – usługa zadziała przy następnym "                "uruchomieniu.")        raise Ostrzezenie(f"{opis}; usługa gotowa, ale Secure Boot blokuje zmianę")    if not SYMULACJA:        zmienione, bledy = ustaw_bd_prochot(False)        if bledy:            raise Ostrzezenie(f"{opis}; nie udało się zmienić {bledy} rdzeni")    return f"{opis} – spowalnianie wyłączone (także przy każdym starcie)"def usun_dell(k: Kontekst) -> None:    systemctl("disable", USLUGA_DELL)    for plik in (f"/etc/systemd/system/{USLUGA_DELL}", HAK_USYPIANIA_DELL, MODULY_DELL, OPCJE_MSR_DELL):        usun_plik(plik)    systemctl("daemon-reload")    if not SYMULACJA and jest_dell() and not blokada_jadra():        ustaw_bd_prochot(True)                        # przywrócenie ustawienia fabrycznego# --- nVidia Unlock RTX ----------------------------------------------------------------------------def karta_rtx_do_odblokowania(sprzet) -> Optional[Tuple["KartaGraficzna", str]]:    """(karta, rodzina nv-uefi-unlocker) dla GeForce RTX 20/30/40, inaczej None."""    for karta in getattr(sprzet, "karty", []) or []:        if karta.vendor != "10de" or "GeForce" not in karta.nazwa:   # tylko GeForce (nie Quadro/RTX A)            continue        for wzorzec, rodzina in NVUNLOCK_RODZINY:            if re.match(r"\s*" + wzorzec, karta.nazwa):                return karta, rodzina    return Nonedef nazwa_karty(karta) -> str:    """„GA104 [GeForce RTX 3070 Ti]” → „GeForce RTX 3070 Ti”."""    m = re.search(r"\[([^\]]+)\]", karta.nazwa)    return m.group(1) if m else karta.nazwadef secure_boot_wlaczony() -> bool:    _, stan = uruchom(["mokutil", "--sb-state"], sprawdz=False, cicho=True, tylko_odczyt=True)    return "enabled" in stan.lower()def partycja_efi() -> Tuple[str, str]:    """(punkt montowania, UUID) partycji EFI."""    _, wynik = uruchom(["findmnt", "-no", "TARGET,UUID", "-T", "/boot/efi"], sprawdz=False,                       cicho=True, tylko_odczyt=True)    pola = wynik.split()    if len(pola) >= 2 and pola[0] != "/":        return pola[0], pola[1]    return "", ""def _pobierz_nvunlock(k: Kontekst) -> str:    """Pobiera najnowsze wydanie nv-uefi-unlocker i zwraca katalog z make-usbroot.sh."""    wydanie = pobierz_json(NVUNLOCK_WYDANIE)    zasoby = [z for z in wydanie.get("assets", []) if re.search(r"\.(zip|tar\.gz|tgz)$", z["name"])              and not re.search(r"windows|source|provenance", z["name"], re.I)]    zasoby.sort(key=lambda z: (0 if "linux" in z["name"].lower() else 1, z["name"]))    if not zasoby:        raise BladPolecenia(f"brak paczki w wydaniu {wydanie.get('tag_name', '?')}")    katalog = os.path.join(k.katalog_tmp, "nvunlock")    plik = pobierz_plik(zasoby[0]["browser_download_url"], os.path.join(k.katalog_tmp, zasoby[0]["name"]))    if SYMULACJA:        return katalog    os.makedirs(katalog, exist_ok=True)    if plik.endswith(".zip"):        with zipfile.ZipFile(plik) as z:            z.extractall(katalog)    else:        import tarfile        with tarfile.open(plik) as t:            t.extractall(katalog, filter="data")    skrypt = next(iter(glob.glob(os.path.join(katalog, "**", "make-usbroot.sh"), recursive=True)), "")    if not skrypt:        raise BladPolecenia("w paczce nie ma make-usbroot.sh")    for plik_wyk in glob.glob(os.path.join(os.path.dirname(skrypt), "assets*")):        os.chmod(plik_wyk, 0o755)    log(f"nv-uefi-unlocker {wydanie.get('tag_name', '')}: {zasoby[0]['name']}")    return os.path.dirname(skrypt)def krok_nvidia_rtx(k: Kontekst) -> str:    karta = karta_rtx_do_odblokowania(k.sprzet)    if not karta:        raise Pominiety("brak karty GeForce RTX 20/30/40")    if not k.nvidia_rtx:        raise Pominiety("nie wybrano")    if not os.path.isdir("/sys/firmware/efi") and not SYMULACJA:        raise Ostrzezenie("komputer nie startuje w trybie UEFI – odblokowanie niemożliwe")    efi, uuid = partycja_efi()    if not efi and not SYMULACJA:        raise Ostrzezenie("nie znaleziono partycji EFI (/boot/efi)")    efi, uuid = efi or "/boot/efi", uuid or "SYMULACJA"    karta_gpu, rodzina = karta    oznacz_dodatek("nvidia_rtx")    # 1) pliki nv-uefi-unlocker dla tej karty (firmware NVIDIA pobiera i sprawdza skrypt projektu)    zrodla = _pobierz_nvunlock(k)    wyjscie = os.path.join(k.katalog_tmp, "nvunlock-efi")    uruchom(["bash", os.path.join(zrodla, "make-usbroot.sh"), "--family", rodzina, "--out", wyjscie,             "--work", os.path.join(k.katalog_tmp, "nvunlock-pobrane"), "--no-install-prompt",             "--skip-gsp-check"])    pliki = [] if SYMULACJA else [p for p in os.listdir(wyjscie) if os.path.isfile(os.path.join(wyjscie, p))]    efi_plik = os.path.join(wyjscie, "EFI", "BOOT", "BOOTX64.EFI")    if not SYMULACJA:        if not os.path.exists(efi_plik):            raise BladPolecenia("make-usbroot.sh nie utworzył BOOTX64.EFI")        potrzeba = sum(os.path.getsize(os.path.join(wyjscie, p)) for p in pliki) + os.path.getsize(efi_plik)        if shutil.disk_usage(efi).free < potrzeba + 16 * 1024 * 1024:            raise Ostrzezenie(f"za mało miejsca na partycji EFI (potrzeba {potrzeba // 2**20} MB)")    # 2) na partycję EFI: pliki w katalogu głównym (wymóg narzędzia), program w osobnym katalogu    zapisane = []    for p in pliki:        kopiuj_plik(os.path.join(wyjscie, p), os.path.join(efi, p))        zapisane.append(os.path.join(efi, p))    cel_efi = os.path.join(efi, NVUNLOCK_KATALOG_EFI, "BOOTX64.EFI")    kopiuj_plik(efi_plik, cel_efi)    zapisane.append(cel_efi)    nastepny = next((s for s in (r"\EFI\debian\shimx64.efi", r"\EFI\debian\grubx64.efi")                     if os.path.exists(os.path.join(efi, s.strip("\\").replace("\\", "/")))),                    r"\EFI\debian\grubx64.efi")    zapisz_plik(os.path.join(efi, "chain-target.txt"),                "# Jabłoński KOMPUTERY – po odblokowaniu wróć do Debiana\n" + nastepny + "\n")    zapisane.append(os.path.join(efi, "chain-target.txt"))    zapisz_plik(NVUNLOCK_PLIKI, "\n".join(zapisane) + "\n")    # 3) pozycja w menu GRUB i widoczne menu (5 s)    zapisz_plik(NVUNLOCK_GRUB, f"""#!/bin/shexec tail -n +3 $0menuentry '{NVUNLOCK_POZYCJA}' --class nvidia {{    insmod part_gpt    insmod part_msdos    insmod fat    insmod chain    search --no-floppy --fs-uuid --set=root {uuid}    echo 'nv-uefi-unlocker: na następnym ekranie naciśnij Spację (inny klawisz = zwykły start)'    chainloader /{NVUNLOCK_KATALOG_EFI}/BOOTX64.EFI}}""", 0o755)    zapisz_plik(NVUNLOCK_GRUB_MENU, "# Jabłoński KOMPUTERY – menu widoczne, bo jest pozycja nVidia Unlock RTX\n"                                    "GRUB_TIMEOUT=5\nGRUB_TIMEOUT_STYLE=menu\n")    # 4) sterownik: bez usypiania karty (kasuje odblokowanie); Turing – firmware GSP    opcje_sterownika = ["options nvidia NVreg_DynamicPowerManagement=0x00"]    if rodzina == "tu10x":        opcje_sterownika.append("options nvidia NVreg_EnableGpuFirmware=1")    zapisz_plik(NVUNLOCK_MODPROBE, "# Jabłoński KOMPUTERY – nVidia Unlock RTX\n"                                   + "\n".join(opcje_sterownika) + "\n")    k.flagi["initramfs"] = True    uruchom(["update-grub"])    k.uwaga(f"nVidia Unlock RTX: przy starcie wybierz w menu „{NVUNLOCK_POZYCJA}” i na ekranie "            "narzędzia naciśnij Spację. Odblokowanie trwa do wyłączenia komputera. Czarny ekran "            "lub zawieszenie: wyłącz komputer przyciskiem zasilania i wybierz zwykłe „Debian”.")    if not SYMULACJA and secure_boot_wlaczony():        k.uwaga("nVidia Unlock RTX wymaga wyłączenia Secure Boot w BIOS/UEFI – przy włączonym "                "pozycja w menu nie uruchomi narzędzia.")        raise Ostrzezenie(f"{karta_gpu.nazwa}: przygotowano, ale Secure Boot jest włączony")    return f"{karta_gpu.nazwa}: pozycja w menu startowym gotowa"def usun_nvidia_rtx(k: Kontekst) -> None:    for plik in [l.strip() for l in czytaj(NVUNLOCK_PLIKI).splitlines() if l.strip()]:        usun_plik(plik)    efi, _ = partycja_efi()    if efi:        usun_plik(os.path.join(efi, NVUNLOCK_KATALOG_EFI))        usun_plik(os.path.join(efi, "loader.log"))          # dziennik narzędzia    for plik in (NVUNLOCK_PLIKI, NVUNLOCK_GRUB, NVUNLOCK_GRUB_MENU, NVUNLOCK_MODPROBE):        usun_plik(plik)    k.flagi["initramfs"] = True    uruchom(["update-grub"], sprawdz=False)# --- Krok: aktualizacje -----------------------------------------------------------------------def krok_aktualizacje(k: Kontekst) -> str:    # 1) od razu: cały system i Flatpaki do najnowszych wersji    apt_update()    uruchom(["apt-get", "full-upgrade", *APT_OPCJE])    uruchom(["apt-get", "autoremove", "-y"], sprawdz=False)    if shutil.which("flatpak"):        uruchom(["flatpak", "update", "-y", "--noninteractive", "--system"], sprawdz=False)    # 2) później: Discover – automatycznie, raz w miesiącu    ustaw_kde(k, "PlasmaDiscoverUpdates", {"Global": {        "UseUnattendedUpdates": "true", "RequiredNotificationInterval": str(AKTUALIZACJE_CO_SEKUND)}})    k.flagi["aktualizacja"] = True    return "system zaktualizowany; dalej automatycznie co miesiąc"# --- Krok: sieć (IPv6, DNS) --------------------------------------------------------------------DISPATCHER_IPV6 = """#!/bin/sh# Jabłoński KOMPUTERY: każda nowa sieć przewodowa i Wi-Fi dostaje wyłączone IPv6[ "$2" = "up" ] || exit 0[ -n "$CONNECTION_UUID" ] || exit 0case "$(nmcli -g connection.type connection show "$CONNECTION_UUID" 2>/dev/null)" in  802-3-ethernet|802-11-wireless) ;;  *) exit 0 ;;esac[ "$(nmcli -g ipv6.method connection show "$CONNECTION_UUID")" = "disabled" ] && exit 0nmcli connection modify "$CONNECTION_UUID" ipv6.method disabled[ -n "$DEVICE_IFACE" ] && nmcli device reapply "$DEVICE_IFACE" >/dev/null 2>&1exit 0"""def krok_siec(k: Kontekst) -> str:    if not shutil.which("nmcli") and not SYMULACJA:        raise Pominiety("brak NetworkManagera")    # DNS dla wszystkich sieci (globalnie w NetworkManagerze – także dla nowych sieci)    zapisz_plik(NM_DNS, "# Jabłoński KOMPUTERY – serwery DNS dla wszystkich połączeń\n"                        "[global-dns-domain-*]\nservers=" + ",".join(SERWERY_DNS) + "\n")    # IPv6: domyślnie wyłączone w nowych połączeniach, w istniejących i w jądrze    zapisz_plik(NM_IPV6, "[connection]\nipv6.method=disabled\n")    zapisz_plik(NM_DISPATCHER_IPV6, DISPATCHER_IPV6, 0o755)    zapisz_plik(SYSCTL_IPV6, "# Jabłoński KOMPUTERY – IPv6 wyłączone (oprócz lo)\n"                             "net.ipv6.conf.all.disable_ipv6 = 1\n"                             "net.ipv6.conf.default.disable_ipv6 = 1\n"                             "net.ipv6.conf.lo.disable_ipv6 = 0\n")    _, polaczenia = uruchom(["nmcli", "-t", "-f", "UUID,TYPE", "connection", "show"],                            sprawdz=False, cicho=True, tylko_odczyt=True)    zmienione = 0    for linia in polaczenia.splitlines():        uuid, _, typ = linia.partition(":")        if typ in ("802-3-ethernet", "802-11-wireless"):            kod, _ = uruchom(["nmcli", "connection", "modify", uuid, "ipv6.method", "disabled"],                             sprawdz=False)            zmienione += kod == 0    uruchom(["sysctl", "--system"], sprawdz=False, cicho=True)    uruchom(["nmcli", "general", "reload"], sprawdz=False)    _, aktywne = uruchom(["nmcli", "-t", "-f", "DEVICE,TYPE", "device", "status"],                         sprawdz=False, cicho=True, tylko_odczyt=True)    for linia in aktywne.splitlines():        urzadzenie, _, typ = linia.partition(":")        if typ in ("ethernet", "wifi"):            uruchom(["nmcli", "device", "reapply", urzadzenie], sprawdz=False, cicho=True)    k.uwaga("Serwery DNS to teraz " + " i ".join(SERWERY_DNS) + ". Jeśli w firmie działa "            "własny serwer DNS (nazwy komputerów w sieci firmowej), usuń plik " + NM_DNS + ".")    return f"IPv6 wyłączone (połączeń: {zmienione}), DNS: " + ", ".join(SERWERY_DNS)# --- Krok: zapora sieciowa -----------------------------------------------------------------------def krok_zapora(k: Kontekst) -> str:    apt_zainstaluj(["ufw"], ["plasma-firewall"])    uruchom(["ufw", "default", "deny", "incoming"])    uruchom(["ufw", "default", "allow", "outgoing"])    for siec in SIECI_LOKALNE:        for opis, porty, protokol in ZAPORA_USLUGI:            komentarz = "JK " + opis.translate(BEZ_POLSKICH)       # ufw: komentarze ASCII            uruchom(["ufw", "allow", "from", siec, "to", "any", "port", porty, "proto", protokol,                     "comment", komentarz], sprawdz=False, cicho=True)    uruchom(["ufw", "--force", "enable"])    systemctl("enable", "ufw")    if "docker" in k.flagi.get("zainstalowane", []) or shutil.which("docker"):        k.uwaga("Zapora: porty kontenerów Docker publikowane na zewnątrz (-p) omijają ufw.")    return "ufw włączony; z sieci lokalnej: KDE Connect, RustDesk, SMB, NFS, drukarki, mDNS, Steam"# --- Krok: wygląd (domyślne dla nowych kont; konta istniejące – tryb sesji) -------------------def krok_wyglad(k: Kontekst) -> str:    ustaw_kde(k, "kdeglobals", {        "General": {"ColorScheme": SCHEMAT_KOLOROW, "AccentColor": KOLOR_AKCENTU_KDE,                    "accentColorFromWallpaper": "false"},        "KDE": {"LookAndFeelPackage": MOTYW_KDE},    }, uzytkownicy=False)    return "jasny Breeze z pomarańczowym akcentem (domyślnie dla nowych kont)"# --- Krok: ekran startowy (Plymouth z logo) --------------------------------------------------def motyw_plymouth() -> Tuple[str, str]:    """Pliki motywu Plymouth: (opis .plymouth, skrypt). Logo na środku ekranu,    pomniejszane do połowy ekranu; obsługa pytania o hasło szyfrowanego dysku."""    r, g, b = KOLOR_TLA_STARTU    tr, tg, tb = KOLOR_TEKSTU_STARTU    opis = textwrap.dedent(f"""\        [Plymouth Theme]        Name=Jabłoński KOMPUTERY        Description=Logo Jabłoński KOMPUTERY na czarnym tle z napisem o uruchamianiu        ModuleName=script        [script]        ImageDir={PLYMOUTH_KATALOG}        ScriptFile={PLYMOUTH_KATALOG}/{PLYMOUTH_MOTYW}.script        """)    skrypt = textwrap.dedent(f"""\        # Jabłoński KOMPUTERY – ekran startowy: logo na środku czarnego ekranu, pod nim napis        Window.SetBackgroundTopColor({r}, {g}, {b});        Window.SetBackgroundBottomColor({r}, {g}, {b});        logo.image = Image("logo.png");        skala = Math.Min(Window.GetWidth() * 0.5 / logo.image.GetWidth(),                         Window.GetHeight() * 0.5 / logo.image.GetHeight());        if (skala < 1) {{            logo.image = logo.image.Scale(logo.image.GetWidth() * skala,                                          logo.image.GetHeight() * skala);        }}        logo.sprite = Sprite(logo.image);        logo.x = Window.GetX() + Window.GetWidth() / 2 - logo.image.GetWidth() / 2;        logo.y = Window.GetY() + Window.GetHeight() / 2 - logo.image.GetHeight() / 2;        logo.sprite.SetPosition(logo.x, logo.y, 0);        # Napis pod logo        napis.image = Image.Text("{NAPIS_STARTU}", {tr}, {tg}, {tb}, 1, "{CZCIONKA_STARTU}");        napis.sprite = Sprite(napis.image);        napis.y = logo.y + logo.image.GetHeight() + 30;        napis.sprite.SetPosition(Window.GetX() + Window.GetWidth() / 2 - napis.image.GetWidth() / 2,                                 napis.y, 1);        # Pytanie o hasło (szyfrowany dysk) – pod napisem        fun pokaz_haslo(pytanie, kropki) {{            tekst = pytanie + "   ";            i = 0;            while (i < kropki) {{                tekst = tekst + "*";                i = i + 1;            }}            global.haslo.image = Image.Text(tekst, {tr}, {tg}, {tb}, 1, "{CZCIONKA_STARTU}");            global.haslo.sprite = Sprite(global.haslo.image);            global.haslo.sprite.SetPosition(                Window.GetX() + Window.GetWidth() / 2 - global.haslo.image.GetWidth() / 2,                global.napis.y + global.napis.image.GetHeight() + 30, 1);            global.haslo.sprite.SetOpacity(1);        }}        fun ukryj_haslo() {{            if (global.haslo.sprite) {{                global.haslo.sprite.SetOpacity(0);            }}        }}        Plymouth.SetDisplayPasswordFunction(pokaz_haslo);        Plymouth.SetDisplayNormalFunction(ukryj_haslo);        """)    return opis, skryptdef krok_ekran_startowy(k: Kontekst) -> str:    pobierz_obraz(k.grafika.get("logo_start") or LOGO_URL, LOGO_START_PLIK)    apt_zainstaluj(["plymouth"], ["plymouth-themes", "plymouth-label"])    opis, skrypt = motyw_plymouth()    zapisz_plik(f"{PLYMOUTH_KATALOG}/{PLYMOUTH_MOTYW}.plymouth", opis)    zapisz_plik(f"{PLYMOUTH_KATALOG}/{PLYMOUTH_MOTYW}.script", skrypt)    kopiuj_plik(LOGO_START_PLIK, f"{PLYMOUTH_KATALOG}/logo.png")    uruchom(["plymouth-set-default-theme", PLYMOUTH_MOTYW])    uruchom(["update-initramfs", "-u"])    if not SYMULACJA and not zainstalowany("plymouth-label"):        raise Ostrzezenie("logo ustawione, ale brak pakietu plymouth-label – napis "                          f"„{NAPIS_STARTU}” nie będzie widoczny")    return f"logo na czarnym tle z napisem „{NAPIS_STARTU}” (działa z opcją „splash” w GRUB)"# --- Krok: GRUB ------------------------------------------------------------------------------def inne_systemy() -> List[str]:    """Inne systemy na dyskach (os-prober + wpisy w obecnym menu GRUB)."""    wynik = set()    if shutil.which("os-prober"):        _, wyjscie = uruchom(["os-prober"], sprawdz=False, cicho=True, tylko_odczyt=True)        for linia in wyjscie.splitlines():            czesci = linia.split(":")            if len(czesci) >= 2 and czesci[0].startswith("/dev/"):                wynik.add(czesci[1] or czesci[0])    for m in re.finditer(r"^\s*menuentry\s+['\"]([^'\"]+)", czytaj("/boot/grub/grub.cfg"), re.M):        if not re.search(r"debian|uefi|firmware|memtest|memory|ustawienia", m.group(1), re.I):            wynik.add(m.group(1))    return sorted(wynik)def krok_grub(k: Kontekst) -> str:    if not os.path.exists("/etc/default/grub") and not SYMULACJA:        raise Pominiety("system nie używa GRUB")    m = re.search(r'^GRUB_CMDLINE_LINUX_DEFAULT="([^"]*)"', czytaj("/etc/default/grub"), re.M)    parametry = m.group(1).split() if m else []    for p in ("quiet", "splash"):          # „splash” włącza graficzny ekran startowy (Plymouth)        if p not in parametry:            parametry.append(p)    linie = ["# Jabłoński KOMPUTERY – szybki start i ekran startowy z logo",             f'GRUB_CMDLINE_LINUX_DEFAULT="{" ".join(parametry)}"']    inne = inne_systemy()    if inne:        opis = "menu GRUB zostaje – wykryto inne systemy: " + ", ".join(inne)    else:        # 1 s niewidocznego oczekiwania: start jest natychmiastowy, a w razie awarii        # klawisz Esc wciąż pokaże menu        linie += ["GRUB_TIMEOUT=1", "GRUB_TIMEOUT_STYLE=hidden"]        opis = "bez menu – system startuje od razu (Esc pokazuje menu)"    zapisz_plik("/etc/default/grub.d/90-jablonski.cfg", "\n".join(linie) + "\n")    uruchom(["update-grub"])    return opis# --- Krok: „O tym systemie” (Ośrodek informacji KDE) --------------------------------------------KANDYDACI_LOGO_DEBIANA = [    "/usr/share/desktop-base/debian-logos/logo-256.png",    "/usr/share/desktop-base/debian-logos/logo-128.png",    "/usr/share/icons/hicolor/256x256/apps/debian-logo.png",    "/usr/share/icons/desktop-base/256x256/emblems/emblem-debian.png",    "/usr/share/pixmaps/debian-logo.png",    "/usr/share/desktop-base/debian-logos/logo.svg",]def znajdz_logo_debiana() -> Optional[str]:    kandydaci = KANDYDACI_LOGO_DEBIANA + sorted(glob.glob("/usr/share/icons/*/*/*/debian-logo.png"),                                                reverse=True)    return next((p for p in kandydaci if os.path.exists(p)), None)def zloz_logo(cel: str, *obrazy: str) -> int:    """Składa obrazy jeden pod drugim (logo Debiana, a pod nim logo J.K.).    Uruchamiane w osobnym procesie: python3 optymalizator_jk.py --zloz-logo CEL OBRAZ..."""    os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")    from PyQt6.QtCore import Qt    from PyQt6.QtGui import QGuiApplication, QImage, QPainter    aplikacja = QGuiApplication([])          # wymagana przez wtyczki formatów obrazów Qt    wczytane = []    for sciezka in obrazy:        obraz = QImage(sciezka) if sciezka and os.path.exists(sciezka) else QImage()        if not obraz.isNull():            wczytane.append(obraz.scaled(256, 256, Qt.AspectRatioMode.KeepAspectRatio,                                         Qt.TransformationMode.SmoothTransformation))    if not wczytane:        return 1    odstep = 32    szer = max(o.width() for o in wczytane)    wys = sum(o.height() for o in wczytane) + odstep * (len(wczytane) - 1)    wynik = QImage(szer, wys, QImage.Format.Format_ARGB32)    wynik.fill(Qt.GlobalColor.transparent)    p = QPainter(wynik)    y = 0    for o in wczytane:        p.drawImage((szer - o.width()) // 2, y, o)        y += o.height() + odstep    p.end()    os.makedirs(os.path.dirname(cel), exist_ok=True)    zapisano = wynik.save(cel)    aplikacja.quit()    return 0 if zapisano else 1def krok_o_systemie(k: Kontekst) -> str:    pobierz_obraz(k.grafika.get("logo") or LOGO_URL, LOGO_PLIK)        # zawsze aktualne (panel)    logo = LOGO_PLIK    debian = znajdz_logo_debiana()    kod, _ = uruchom(["/usr/bin/python3", SKRYPT, "--zloz-logo", LOGO_O_SYSTEMIE, debian or "",                      LOGO_PLIK], sprawdz=False, srodowisko={"QT_QPA_PLATFORM": "offscreen"})    if kod == 0:        logo = LOGO_O_SYSTEMIE    else:        log("Nie udało się złożyć logo Debiana z logo J.K. – używam samego logo J.K.")    plik = "/etc/xdg/kcm-about-distrorc"    if os.path.exists(plik) and "jablonski" not in czytaj(plik).lower():        kopiuj_plik(plik, plik + ".przed-jablonski")       # kopia oryginału    ini = IniPlik(plik)    ini.ustaw("General", "LogoPath", logo)    ini.ustaw("General", "Website", STRONA_O_SYSTEMIE)      # klikany link    # „\n” w pliku KDE oznacza nową linię    ini.ustaw("General", "Variant", NAPIS_O_SYSTEMIE.replace("\n", "\\n"))   # napis przy logo    ini.zapisz()    return ("logo Debiana + J.K." if logo == LOGO_O_SYSTEMIE else "logo J.K.") + \        ", napis i adres forum"# --- Krok: nazwa komputera -----------------------------------------------------------------------def krok_nazwa_komputera(k: Kontekst) -> str:    if not k.nazwa:        raise Pominiety("nazwa bez zmian")    host = nazwa_hosta(k.nazwa)    if not host:        raise BladPolecenia("nazwa musi zawierać litery lub cyfry")    stara = socket.gethostname()    # /etc/hosts najpierw – inaczej sudo zgłasza „unable to resolve host”    linie, jest = [], False    for linia in czytaj("/etc/hosts").splitlines():        czesci = linia.split()        if czesci and czesci[0] == "127.0.1.1":            linia, jest = f"127.0.1.1\t{host}", True        elif len(czesci) > 1 and not czesci[0].startswith("#") and stara not in ("", "localhost") \                and stara in czesci[1:]:            linia = "\t".join([czesci[0]] + [host if c == stara else c for c in czesci[1:]])        linie.append(linia)    if not jest:        linie.insert(1 if linie else 0, f"127.0.1.1\t{host}")    zapisz_plik("/etc/hosts", "\n".join(linie) + "\n")    uruchom(["hostnamectl", "set-hostname", host])               # nazwa sieciowa    uruchom(["hostnamectl", "set-hostname", "--pretty", k.nazwa])  # ładna nazwa (Bluetooth, KDE)    # KDE Connect – nazwa widoczna na telefonie (nowe konta: tryb sesji)    ustaw_kde(k, "kdeconnect/config", {"General": {"name": k.nazwa}}, systemowo=False)    k.uwaga("Nowa nazwa komputera zadziała w pełni po restarcie.")    return f"„{k.nazwa}” (w sieci: {host})"# --- Krok: pulpit, pasek zadań, ulubione (tryb sesji) ------------------------------------------------DESKTOP_TEN_KOMPUTER = """\[Desktop Entry]Type=LinkName=Ten komputerComment=Twoje pliki i dyskiIcon=computerURL[$e]=file:$HOME"""DESKTOP_KOSZ = f"""\[Desktop Entry]Type=LinkName=KoszComment=Usunięte pliki – po {KOSZ_DNI} dniach znikają sameIcon=user-trash-fullEmptyIcon=user-trashURL=trash:/"""DESKTOP_AUTOSTART_SESJI = f"""\[Desktop Entry]Type=ApplicationName=Jabłoński KOMPUTERY – ustawienia pulpituComment=Jednorazowe ustawienie pulpitu, paska zadań i menu po zalogowaniuExec=/usr/bin/python3 {SKRYPT_SYSTEMOWY} --sesjaOnlyShowIn=KDE;NoDisplay=trueX-KDE-autostart-phase=2"""def pliki_pulpitu() -> List[Tuple[str, str, int]]:    """Ikony na Pulpicie: (nazwa pliku, treść, uprawnienia)."""    return [("ten-komputer.desktop", DESKTOP_TEN_KOMPUTER, 0o644),            ("kosz.desktop", DESKTOP_KOSZ, 0o644),            (JK_DESKTOP, DESKTOP_JK, 0o755)]def krok_pulpit(k: Kontekst) -> str:    # 1) Kopia programu w miejscu systemowym – z niej korzysta tryb sesji przy logowaniu    if SKRYPT != SKRYPT_SYSTEMOWY:        kopiuj_plik(SKRYPT, SKRYPT_SYSTEMOWY, 0o755)    zapisz_plik(AUTOSTART_SESJI, DESKTOP_AUTOSTART_SESJI)    # 2) Szablon Pulpitu dla nowych kont    for nazwa, tresc, tryb in pliki_pulpitu():        zapisz_plik(f"/etc/skel/Pulpit/{nazwa}", tresc, tryb)    # 3) Konta zalogowane teraz – od razu; pozostałe – przy następnym logowaniu    zrobione, bledy = [], []    for u in k.uzytkownicy:        if not u.zalogowany and not SYMULACJA:            continue        kod, _ = jako_uzytkownik(u, ["/usr/bin/python3", SKRYPT_SYSTEMOWY, "--sesja", "--wymus"],                                 sesja=True, sprawdz=False)        (zrobione if kod == 0 else bledy).append(u.nazwa)    if bledy:        raise Ostrzezenie("nie wszystko udało się ustawić dla: " + ", ".join(bledy) +                          " – szczegóły w ~/.cache/jablonski-komputery-sesja.log")    teraz = ", ".join(zrobione) if zrobione else "brak zalogowanych kont"    return f"od razu: {teraz}; pozostałe konta – przy logowaniu"# --- Krok: komunikaty i zgłaszanie uruchomień -------------------------------------------------USLUGA_START_TRESC = f"""\[Unit]Description=Jabłoński KOMPUTERY – zgłoszenie uruchomienia komputeraWants=network-online.targetAfter=network-online.target[Service]Type=simpleExecStart=/usr/bin/python3 {SKRYPT_SYSTEMOWY} --zglos-startTimeoutStopSec=10[Install]WantedBy=multi-user.target"""USLUGA_STANU_TRESC = f"""\[Unit]Description=Jabłoński KOMPUTERY – stan komputera (pakiet, zgubiony/skradziony)After=NetworkManager.serviceWants=NetworkManager.serviceBefore=display-manager.service[Service]Type=oneshotExecStart=/usr/bin/python3 {SKRYPT_SYSTEMOWY} --stanTimeoutStartSec=30[Install]WantedBy=multi-user.target"""DESKTOP_NAPRAWA = "/usr/share/applications/pl.jablonski_komputery.AktualizujUstawienia.desktop"DESKTOP_NAPRAWA_TRESC = f"""\[Desktop Entry]Type=ApplicationName=Aktualizuj ustawienia (Jabłoński KOMPUTERY)GenericName=Naprawa ustawień systemuComment=Przywraca ustawienia Optymalizatora – tak jak przy instalacji – gdy coś przestało działaćExec=/usr/bin/python3 {SKRYPT_SYSTEMOWY} --naprawIcon=jablonski-komputeryTerminal=falseCategories=System;Settings;Keywords=naprawa;aktualizacja;optymalizator;jablonski;"""USLUGA_AKTUALIZACJI_TRESC = f"""\[Unit]Description=Jabłoński KOMPUTERY – aktualizacja ustawień komputeraWants=network-online.targetAfter=network-online.target[Service]Type=oneshotEnvironment=PYTHONUNBUFFERED=1StateDirectory=jablonski-komputeryExecStartPre=-/usr/bin/find {KATALOG_STANU} -maxdepth 1 -name aktualizacja-*.log -mtime +7 -deleteExecStart=/usr/bin/python3 {SKRYPT_SYSTEMOWY} --aktualizacja %iStandardOutput=truncate:{KATALOG_STANU}/aktualizacja-%i.logStandardError=journalTimeoutStartSec=infinity"""REGULA_AKTUALIZACJI_TRESC = """\// Jabłoński KOMPUTERY – zalogowany użytkownik może bez hasła uruchomić aktualizację ustawień// Optymalizatora (po zmianie pakietu). Tylko ta jedna usługa, tylko start.polkit.addRule(function(action, subject) {    if (action.id == "org.freedesktop.systemd1.manage-units" &&        action.lookup("verb") == "start" &&        /^jablonski-komputery-aktualizacja@u[0-9]+x[0-9a-f]{8}\\.service$/.test(action.lookup("unit") || "") &&        subject.local && subject.active) {        return polkit.Result.YES;    }});"""ZEGAR_STANU_TRESC = f"""\[Unit]Description=Jabłoński KOMPUTERY – sprawdzanie stanu komputera co 10 minut[Timer]OnBootSec=2minOnUnitActiveSec=10minUnit={USLUGA_STANU}[Install]WantedBy=timers.target"""DESKTOP_AUTOSTART_KOMUNIKATOW = f"""\[Desktop Entry]Type=ApplicationName=Jabłoński KOMPUTERY – komunikatyComment=Wyświetla komunikaty od Jabłoński KOMPUTERY po zalogowaniuExec=/usr/bin/python3 {SKRYPT_SYSTEMOWY} --komunikatyOnlyShowIn=KDE;NoDisplay=trueX-KDE-autostart-phase=2"""def krok_komunikaty(k: Kontekst) -> str:    # kod licencji – komputer przedstawia się nim (razem z identyfikatorem sprzętu) serwerowi    if k.klucz:        zapisz_plik(PLIK_LICENCJI, json.dumps({"klucz": k.klucz, "nazwa": k.nazwa or "",                                               "aktywowano": time.strftime("%Y-%m-%d %H:%M:%S"),                                               # opcje, z którymi skonfigurowano komputer – po zmianie                                               # pakietu w panelu program zaproponuje aktualizację                                               "opcje": sorted(k.opcje), "pakiet": nazwa_pakietu(k.opcje),                                               "grafika": k.grafika,                                               # wybory z okna – aktualizacja po zmianie pakietu ich użyje                                               "wybory": {"numlock": k.numlock, "gry": k.gry,                                                          "logitech": k.logitech, "nvidia_rtx": k.nvidia_rtx,                                                          "antykradziez": k.antykradziez,                                                          "uzytkownik": k.uzytkownicy[0].nazwa                                                          if k.uzytkownicy else ""}},                                              ensure_ascii=False, indent=2) + "\n", 0o644)    elif not os.path.exists(PLIK_LICENCJI) and not SYMULACJA:        raise Ostrzezenie("brak kodu licencji – komunikaty i zgłaszanie uruchomień nie zadziałają")    if SKRYPT != SKRYPT_SYSTEMOWY:                    # kopia programu (jak w kroku „Pulpit”)        kopiuj_plik(SKRYPT, SKRYPT_SYSTEMOWY, 0o755)    zapisz_plik(f"/etc/systemd/system/{USLUGA_START}", USLUGA_START_TRESC)    zapisz_plik(AUTOSTART_KOMUNIKATOW, DESKTOP_AUTOSTART_KOMUNIKATOW)    zapisz_plik(f"/etc/systemd/system/{USLUGA_STANU}", USLUGA_STANU_TRESC)    zapisz_plik(f"/etc/systemd/system/{ZEGAR_STANU}", ZEGAR_STANU_TRESC)    zapisz_plik(f"/etc/systemd/system/{USLUGA_AKTUALIZACJI}", USLUGA_AKTUALIZACJI_TRESC)    zapisz_plik(REGULA_AKTUALIZACJI, REGULA_AKTUALIZACJI_TRESC)    zapisz_plik(DESKTOP_NAPRAWA, DESKTOP_NAPRAWA_TRESC)    systemctl("daemon-reload")    systemctl("enable", USLUGA_START, USLUGA_STANU, ZEGAR_STANU)    systemctl("start", "--no-block", USLUGA_START)     # pierwsze zgłoszenie od razu    systemctl("start", "--no-block", ZEGAR_STANU)    return "zgłaszanie uruchomień włączone; komunikaty po zalogowaniu; ochrona na wypadek kradzieży"# --- Kroki: usuwanie programów -------------------------------------------------------------------def usun_zestaw(wzorce: List[str], flatpaki: List[str], snapy: List[str]) -> List[str]:    usuniete = apt_usun_bezpiecznie(wzorce)    for app_id in flatpaki:        if flatpak_zainstalowany(app_id):            uruchom(["flatpak", "uninstall", "-y", "--noninteractive", "--system", app_id],                    sprawdz=False)            usuniete.append(app_id)    if shutil.which("snap"):        _, lista = uruchom(["snap", "list"], sprawdz=False, cicho=True, tylko_odczyt=True)        zainst = {l.split()[0] for l in lista.splitlines()[1:] if l.split()}        for nazwa in snapy:            if nazwa in zainst:                uruchom(["snap", "remove", nazwa], sprawdz=False)                usuniete.append(f"snap:{nazwa}")    return usunietedef krok_usun_biuro(k: Kontekst) -> str:    usuniete = usun_zestaw(WZORCE_BIURO, FLATPAK_BIURO, SNAP_BIURO)    return f"usunięto {liczba(len(usuniete), 'pakiet', 'pakiety', 'pakietów')}" if usuniete \        else "nic do usunięcia"def krok_usun_kde_zbedne(k: Kontekst) -> str:    usuniete = usun_zestaw(WZORCE_KDE_ZBEDNE, FLATPAK_KDE_ZBEDNE, [])    return f"usunięto {liczba(len(usuniete), 'pakiet', 'pakiety', 'pakietów')}" if usuniete \        else "nic do usunięcia"# --- Krok: poczta e-mail ---------------------------------------------------------------------------DESKTOP_RYSUJ = f"""\[Desktop Entry]Type=ApplicationName={RYSUJ_NAZWA}GenericName=Zaznacz, narysuj i wklej do wiadomościComment=Zaznacz fragment ekranu (np. maila), narysuj na nim pisakiem, zakreślaczem, strzałkami \lub dopisz tekst, potem kliknij Kopiuj i wklej do odpowiedzi (Ctrl+V)Exec=spectacle --regionIcon=draw-freehandCategories=Office;Graphics;Utility;Keywords=rysuj;zaznacz;zakreślacz;adnotacje;uwagi;mail;poczta;zrzut;"""def _pobierz_xnote(k: Kontekst) -> bool:    """Pobiera XNote++ do XNOTE_PLIK i sprawdza, czy to naprawdę ten dodatek."""    if SYMULACJA:        log(f"[symulacja] pobranie dodatku XNote++ → {XNOTE_PLIK}")        return True    adresy = list(XNOTE_ADRESY)    try:                         # zapasowo: najnowsze wydanie na GitHubie        wydanie = pobierz_json(XNOTE_GITHUB)        adresy += [z["browser_download_url"] for z in wydanie.get("assets", [])                   if z["name"].endswith(".xpi")]    except Exception:            # noqa: BLE001        pass    tymczasowy = os.path.join(k.katalog_tmp, "xnote.xpi")    for adres in adresy:        try:            pobierz_plik(adres, tymczasowy)            with zipfile.ZipFile(tymczasowy) as z:                manifest = json.loads(z.read("manifest.json").decode("utf-8"))            gecko = (manifest.get("browser_specific_settings") or manifest.get("applications") or {})            if gecko.get("gecko", {}).get("id") == XNOTE_ID:                kopiuj_plik(tymczasowy, XNOTE_PLIK)                log(f"XNote++ {manifest.get('version', '')} pobrany z {adres}")                return True        except Exception as e:   # noqa: BLE001 – próbujemy kolejnego adresu            log(f"XNote++: {adres} – {e}")    return os.path.exists(XNOTE_PLIK)        # zostaje wersja pobrana wcześniejdef profile_poczty(dom: str) -> List[str]:    """Katalogi profili Betterbirda w katalogu domowym (z profiles.ini)."""    katalog = os.path.join(dom, PROFILE_POCZTY)    ini = IniPlik(os.path.join(katalog, "profiles.ini"))    wynik = []    for grupa in ini.grupy():        sciezka = ini.pobierz(grupa, "Path")        if grupa.startswith("Profile") and sciezka:            pelna = os.path.join(katalog, sciezka) if ini.pobierz(grupa, "IsRelative") != "0" else sciezka            if os.path.isdir(pelna):                wynik.append(pelna)    return wynikdef ustaw_profil_poczty(profil: str, wlasciciel: Optional[Uzytkownik] = None) -> List[str]:    """Dokłada XNote++ (raz na profil) i nasze ustawienia w user.js. Zwraca, co zrobiono."""    zrobione = []    znacznik = os.path.join(profil, ZNACZNIK_XNOTE)    if os.path.exists(XNOTE_PLIK) and not os.path.exists(znacznik):        kopiuj_plik(XNOTE_PLIK, os.path.join(profil, "extensions", XNOTE_ID + ".xpi"),                    wlasciciel=wlasciciel)        zapisz_plik(znacznik, "XNote++ dołożony przez Optymalizator – jeśli go usuniesz, "                              "nie wróci.\n", wlasciciel=wlasciciel)        zrobione.append("XNote++")    user_js = os.path.join(profil, "user.js")    linie = [l for l in czytaj(user_js).splitlines()             if not any(f'"{klucz}"' in l for klucz in USTAWIENIA_POCZTY)]    linie += [f'user_pref("{klucz}", {json.dumps(wartosc)});'              for klucz, wartosc in USTAWIENIA_POCZTY.items()]    nowa = "\n".join(linie) + "\n"    if nowa != czytaj(user_js):        zapisz_plik(user_js, nowa, wlasciciel=wlasciciel)        zrobione.append("ustawienia")    return zrobionedef _kopiuj_drzewo(zrodlo: str, cel: str, u: Uzytkownik) -> None:    if SYMULACJA:        log(f"[symulacja] kopiowanie {zrodlo} → {cel}")        return    utworz_katalog(os.path.dirname(cel), u)    shutil.copytree(zrodlo, cel, symlinks=True)    for katalog, podkatalogi, pliki in os.walk(cel):        for nazwa in [katalog] + [os.path.join(katalog, p) for p in podkatalogi + pliki]:            os.lchown(nazwa, u.uid, u.gid)    for langpack in glob.glob(os.path.join(cel, "*", "extensions", "langpack-*@thunderbird.mozilla.org.xpi")):        os.remove(langpack)      # paczki językowe Thunderbirda nie działają w Betterbirdziedef przygotuj_poczte_uzytkownika(u: Uzytkownik) -> str:    katalog = u.sciezka(PROFILE_POCZTY)    opis = ""    if not os.path.isdir(katalog):        stary = next((u.sciezka(s) for s in STARE_PROFILE_POCZTY                      if os.path.isfile(u.sciezka(s, "profiles.ini"))), None)        if stary:                # konta, poczta i książka adresowa z Thunderbirda            _kopiuj_drzewo(stary, katalog, u)            opis = "przeniesiono pocztę z Thunderbirda"        else:                    # pusty profil – żeby dodatek i ustawienia były od pierwszego startu            utworz_katalog(os.path.join(katalog, "jk.default-release"), u)            zapisz_plik(os.path.join(katalog, "profiles.ini"),                        "[Profile0]\nName=default-release\nIsRelative=1\nPath=jk.default-release\n"                        "Default=1\n\n[General]\nStartWithLastProfile=1\nVersion=2\n", wlasciciel=u)    profile = profile_poczty(u.dom) or ([os.path.join(katalog, "jk.default-release")] if SYMULACJA else [])    for profil in profile:        ustaw_profil_poczty(profil, u)    return opis or f"profili: {len(profile)}"def krok_poczta(k: Kontekst) -> str:    # Polskie tłumaczenie: Flatpak instaluje tylko wybrane języki    _, jezyki = uruchom(["flatpak", "config", "--system", "--get", "extra-languages"],                        sprawdz=False, cicho=True, tylko_odczyt=True)    jezyki = [j for j in re.split(r"[;\s]+", jezyki.strip()) if j and j != "*unset*"]    if "pl" not in jezyki:        uruchom(["flatpak", "config", "--system", "--set", "extra-languages", ";".join(jezyki + ["pl"])],                sprawdz=False)    if not flatpak_zainstaluj(FLATPAK_POCZTA):        raise BladPolecenia("Nie udało się zainstalować programu pocztowego Betterbird (Flathub).")    uruchom(["flatpak", "update", "-y", "--noninteractive", "--system", FLATPAK_POCZTA + ".Locale"],            sprawdz=False, cicho=True)    ustaw_skojarzenia(k, {"x-scheme-handler/mailto": DESKTOP_POCZTA,                          "message/rfc822": DESKTOP_POCZTA,                          "x-scheme-handler/mid": DESKTOP_POCZTA})    # Rysowanie po wiadomościach – narzędzie do zrzutów KDE (Spectacle) ma pisak, zakreślacz, strzałki i tekst    apt_zainstaluj([], ["kde-spectacle"])    zapisz_plik(RYSUJ_DESKTOP, DESKTOP_RYSUJ)    xnote = _pobierz_xnote(k)    if not xnote:        k.uwaga("Nie udało się pobrać dodatku XNote++ (karteczki z uwagami). Można go dodać "                "w Betterbirdzie: menu → Dodatki i motywy → wyszukaj „XNote++”.")    wyniki = []    for u in k.uzytkownicy:        try:            wyniki.append(f"{u.nazwa}: {przygotuj_poczte_uzytkownika(u)}")        except OSError as e:            wyniki.append(f"{u.nazwa}: błąd ({e})")    return "Betterbird" + (" + XNote++" if xnote else "") + " + rysowanie; " + "; ".join(wyniki)def sesja_poczta() -> str:    """Przy każdym logowaniu: XNote++ i ustawienia także w profilach utworzonych później."""    profile = profile_poczty(os.path.expanduser("~"))    zrobione = [f"{os.path.basename(p)}: {', '.join(z)}" for p in profile if (z := ustaw_profil_poczty(p))]    return "; ".join(zrobione) or "bez zmian"def krok_usun_mozille(k: Kontekst) -> str:    usuniete = usun_zestaw(WZORCE_MOZILLA, FLATPAK_MOZILLA, SNAP_MOZILLA)    return f"usunięto {liczba(len(usuniete), 'pakiet', 'pakiety', 'pakietów')}" if usuniete \        else "nic do usunięcia"# --- Krok: zakończenie ----------------------------------------------------------------------------def krok_zakonczenie(k: Kontekst) -> str:    uruchom(["update-desktop-database", "-q"], sprawdz=False, cicho=True)    for u in k.uzytkownicy:   # odświeżenie menu KDE (skojarzenia plików, nowe programy)        jako_uzytkownik(u, ["kbuildsycoca6"], sprawdz=False, cicho=True)    uruchom(["apt-get", "clean"], sprawdz=False, cicho=True)    usun_plik(k.katalog_tmp)    k.uwaga("Uruchom komputer ponownie, aby wszystkie zmiany (sterowniki, język, grupy "            "użytkowników, Num Lock) zaczęły działać.")    return "gotowe – potrzebny restart"# ============================================================================# 6. WYKONAWCA KROKÓW# ============================================================================@dataclassclass Krok:    id: str    tytul: str    funkcja: Callable[[Kontekst], str]    krytyczny: bool = False     # błąd = przerwanie (np. brak repozytoriów → nic nie zadziała)def lista_krokow() -> List[Krok]:    kroki = [        Krok("repozytoria", "Repozytoria systemowe", krok_repozytoria, krytyczny=True),        Krok("aktualizacje", "Aktualizacja systemu (teraz i co miesiąc)", krok_aktualizacje),        Krok("jezyk", "Język polski i pakiety językowe", krok_jezyk),        Krok("czcionki", "Czcionki (Microsoft, zamienniki Office, Libre Barcode 39)", krok_czcionki),        Krok("numlock", "Num Lock", krok_numlock),        Krok("hasla", "Hasło tylko raz – przy logowaniu", krok_bez_hasla),        Krok("zasilanie", "Bez wygaszania ekranu i usypiania", krok_zasilanie),        Krok("sklepy", "Snap i Flatpak w Discover", krok_sklepy),        Krok("brave", "Przeglądarka Brave", krok_brave),    ]    kroki += [Krok(a.id, f"ArtCraft {a.nazwa}", zrob_krok_artcraft(a)) for a in ARTCRAFT]    kroki.append(Krok("grafika", "Sterowniki karty graficznej", krok_grafika))    kroki.append(Krok("dell", "DELL Unlock Pin ID (zasilacz)", krok_dell))    kroki.append(Krok("nextcloud", "Nextcloud (klient plików)", krok_nextcloud))    kroki.append(Krok("rustdesk", "RustDesk", krok_rustdesk))    kroki += [Krok(id_, tytul, zrob_krok_apt(wym, dod)) for id_, tytul, wym, dod in PROGRAMY_APT]    kroki.append(Krok("kodeki", "MULTIMEDIA: kodeki audio i wideo (także non-free)", krok_kodeki))    kroki += [        Krok("steam", "Steam", krok_steam),        Krok("wine", "Wine, PlayOnLinux i Proton", krok_wine),        Krok("launchery", "Lutris i Heroic (Epic, GOG, EA, Ubisoft, Rockstar…)", krok_launchery_gier),        Krok("docker", "Docker i Whaler", krok_docker),        Krok("discover_deb", "Pliki .deb otwierane w Discover", krok_discover_deb),        Krok("tapeta", "Tapeta (pulpit i ekran logowania)", krok_tapeta),        Krok("wyglad", "Jasny motyw z pomarańczowym akcentem", krok_wyglad),        Krok("ustawienia_kde", "Ustawienia systemowe KDE", krok_ustawienia_kde),        Krok("ekran_startowy", "Ekran startowy z logo", krok_ekran_startowy),        Krok("grub", "GRUB – start bez menu", krok_grub),        Krok("nvidia_rtx", "nVidia Unlock RTX (AI)", krok_nvidia_rtx),        Krok("o_systemie", "„O tym systemie” – logo i napis J.K.", krok_o_systemie),        Krok("jk", JK_NAZWA, krok_aplikacja_jk),        Krok("poczta", "Poczta e-mail (Betterbird, karteczki, rysowanie)", krok_poczta),        # Usuwanie na końcu: gdyby któryś pakiet pociągnął LibreOffice/Firefox jako        # zależność polecaną, i tak zostanie usunięty.        Krok("usun_biuro", "Usunięcie LibreOffice, OpenOffice i innych", krok_usun_biuro),        Krok("usun_mozilla", "Usunięcie Firefox i Thunderbird", krok_usun_mozille),        Krok("usun_kde", "Usunięcie KMail, KOrganizer, Konqueror i innych", krok_usun_kde_zbedne),        Krok("nazwa", "Nazwa komputera", krok_nazwa_komputera),        Krok("pulpit", "Pulpit, pasek zadań i ulubione", krok_pulpit),        Krok("komunikaty", "Komunikaty i zgłaszanie uruchomień", krok_komunikaty),        Krok("antykradziez", "J.K. Anty-Kradzież", krok_antykradziez),        Krok("logitech", "Urządzenia Logitech (podświetlenie, G19s)", krok_logitech),        Krok("siec", "Sieć: IPv6 wyłączone, DNS 8.8.8.8 i 1.1.1.1", krok_siec),        Krok("zapora", "Zapora sieciowa (KDE Connect, RustDesk, SMB, NFS w LAN)", krok_zapora),        Krok("sprzatanie", "Usuwanie niepotrzebnych dodatków", krok_sprzatanie),        Krok("koniec", "Porządki końcowe", krok_zakonczenie),    ]    return krokiclass Raport:    """Przekazuje zdarzenia do okna (tryb 'json') albo wypisuje je w terminalu."""    SYMBOLE = {"ok": "✔", "ostrzezenie": "⚠", "blad": "✖", "pominiety": "–"}    def __init__(self, tryb: str):        self.tryb = tryb        self.plik = None        self.tytuly: Dict[str, str] = {}        self.liczba = 0        sciezka = None        if tryb == "sesja":            sciezka = os.path.expanduser("~/.cache/jablonski-komputery-sesja.log")        elif not SYMULACJA and os.geteuid() == 0:            sciezka = PLIK_DZIENNIKA        if sciezka:            try:                os.makedirs(os.path.dirname(sciezka), exist_ok=True)                self.plik = open(sciezka, "a", encoding="utf-8")                self.plik.write(f"\n===== {time.strftime('%Y-%m-%d %H:%M:%S')} "                                f"{NAZWA_PROGRAMU} {WERSJA} =====\n")            except OSError:                self.plik = None    def log(self, tekst: str) -> None:        self.zdarzenie({"typ": "log", "tekst": tekst})    def zdarzenie(self, z: dict) -> None:        if self.plik:            if z["typ"] == "log":                self.plik.write(z["tekst"] + "\n")            else:                self.plik.write("## " + json.dumps(z, ensure_ascii=False) + "\n")            self.plik.flush()        if self.tryb == "json":            sys.stdout.write(PREFIKS_ZDARZENIA + json.dumps(z) + "\n")            sys.stdout.flush()            return        if self.tryb == "sesja":            if z["typ"] == "log":                print(z["tekst"], flush=True)            return        # --- tryb tekstowy ---        typ = z["typ"]        if typ == "lista_krokow":            self.tytuly = {x["id"]: x["tytul"] for x in z["kroki"]}            self.liczba = len(z["kroki"])        elif typ == "krok" and z["stan"] == "trwa":            nr = list(self.tytuly).index(z["id"]) + 1            print(f"\n[{nr}/{self.liczba}] ▶ {self.tytuly[z['id']]}", flush=True)        elif typ == "krok":            print(f"   {self.SYMBOLE.get(z['stan'], '?')} {z.get('info', '')}", flush=True)        elif typ == "log":            print("      " + z["tekst"], flush=True)        elif typ == "koniec":            p = z["podsumowanie"]            print(f"\n=== Zakończono: ✔ {p['ok']}  ⚠ {p['ostrzezenie']}  ✖ {p['blad']}  "                  f"– {p['pominiety']} ===")            for u in z["uwagi"]:                print(textwrap.fill(u, 88, initial_indent=" • ", subsequent_indent="   "))            print(f"\nDziennik: {PLIK_DZIENNIKA}")def wykonaj_kroki(k: Kontekst) -> dict:    # kroki opcji spoza pakietu klienta nie pojawiają się na liście    kroki = [x for x in lista_krokow()             if (x.id not in KROKI_OPCJI or any(o in k.opcje for o in KROKI_OPCJI[x.id]))             and (x.id != "sprzatanie" or k.flagi.get("do_usuniecia"))             and (x.id != "dell" or jest_dell() or SYMULACJA)             and (x.id != "nvidia_rtx" or karta_rtx_do_odblokowania(k.sprzet) or SYMULACJA)]    RAPORT.zdarzenie({"typ": "lista_krokow",                      "kroki": [{"id": x.id, "tytul": x.tytul} for x in kroki]})    licznik = {"ok": 0, "ostrzezenie": 0, "blad": 0, "pominiety": 0}    przerwano = False    for nr, krok in enumerate(kroki):        if przerwano:            stan, info = "pominiety", "przerwano po krytycznym błędzie"        else:            RAPORT.zdarzenie({"typ": "krok", "id": krok.id, "stan": "trwa"})            log(f"===== {krok.tytul} =====")            try:                stan, info = "ok", krok.funkcja(k) or "gotowe"            except Ostrzezenie as e:                stan, info = "ostrzezenie", str(e)                k.uwaga(f"{krok.tytul}: {e}")            except Pominiety as e:                stan, info = "pominiety", str(e)            except Exception as e:            # noqa: BLE001 – każdy błąd kroku raportujemy                stan, info = "blad", str(e) or e.__class__.__name__                log(traceback.format_exc())                k.uwaga(f"{krok.tytul}: BŁĄD – {info}")                przerwano = krok.krytyczny        licznik[stan] += 1        RAPORT.zdarzenie({"typ": "krok", "id": krok.id, "stan": stan, "info": info})        RAPORT.zdarzenie({"typ": "postep", "procent": int((nr + 1) * 100 / len(kroki))})    RAPORT.zdarzenie({"typ": "koniec", "uwagi": k.uwagi, "podsumowanie": licznik})    return licznikdef zablokuj_usypianie_systemu() -> Optional[subprocess.Popen]:    """Na czas pracy: komputer nie uśnie (bezczynność, klapa, przycisk uśpienia).    Blokada logind trwa, dopóki działa proces systemd-inhibit – kończymy go po zakończeniu."""    if SYMULACJA or not shutil.which("systemd-inhibit"):        return None    try:        return subprocess.Popen(            ["systemd-inhibit",             "--what=sleep:idle:handle-lid-switch:handle-suspend-key:handle-hibernate-key",             "--who=" + NAZWA_PROGRAMU, "--why=Trwa optymalizacja systemu – nie wyłączaj komputera",             "--mode=block", "sleep", "infinity"],            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)    except OSError:        return Nonedef odswiez_ustawienia_sesji(k: "Kontekst") -> None:    """Zalogowane sesje KDE od razu wczytują nowe ustawienia blokady ekranu i zasilania    (inaczej obowiązywałyby dopiero po ponownym zalogowaniu)."""    wywolania = [        ("org.freedesktop.ScreenSaver", "/ScreenSaver", "org.kde.screensaver", "configure"),        ("org.kde.Solid.PowerManagement", "/org/kde/Solid/PowerManagement",         "org.kde.Solid.PowerManagement", "refreshStatus"),        ("org.kde.Solid.PowerManagement", "/org/kde/Solid/PowerManagement",         "org.kde.Solid.PowerManagement", "reparseConfiguration"),        ("org.kde.KWin", "/KWin", "org.kde.KWin", "reconfigure"),     # szybkość animacji    ]    for u in k.uzytkownicy:        if not u.zalogowany and not SYMULACJA:            continue        for usluga, sciezka, interfejs, metoda in wywolania:            jako_uzytkownik(u, ["busctl", "--user", "call", usluga, sciezka, interfejs, metoda],                            sesja=True, sprawdz=False, cicho=True)def uruchom_wykonawce(numlock: bool, uzytkownik: Optional[str], tryb: str,                      nazwa: Optional[str] = None, ryzyko: bool = False,                      klucz: str = "", logitech: Optional[List[str]] = None,                      gry: bool = True, opcje: Optional[List[str]] = None,                      nvidia_rtx: bool = False, antykradziez: bool = False,                      grafika: Optional[Dict[str, str]] = None) -> int:    """Punkt wejścia części działającej z uprawnieniami administratora."""    global RAPORT    RAPORT = Raport(tryb)    if not SYMULACJA and (not jest_kde() or (not jest_debian13() and not ryzyko)):        powod = TEKST_BRAK_KDE if not jest_kde() else (            f"Wykryto: {nazwa_systemu()}. {TEKST_RYZYKO} Uruchom program ponownie i potwierdź ryzyko.")        log(powod)        RAPORT.zdarzenie({"typ": "lista_krokow", "kroki": []})        RAPORT.zdarzenie({"typ": "koniec", "uwagi": [powod],                          "podsumowanie": {"ok": 0, "ostrzezenie": 0, "blad": 1, "pominiety": 0}})        return 4    try:        usun_plik(REGULA_STARTOWA)          # jednorazowa zgoda polkit już wykorzystana        sprzet = wykryj_sprzet(sprawdz_internet=False)        uzytkownicy = lista_uzytkownikow(uzytkownik)        log(f"System: {sprzet.system.get('PRETTY_NAME')} | host: {sprzet.host} | "            f"laptop: {'tak' if sprzet.laptop else 'nie'}")        for karta in sprzet.karty:            log(f"Karta: {karta.nazwa} [{karta.vendor}:{karta.device:04x}] "                f"sterownik={karta.sterownik or '-'} moduły={','.join(karta.moduly) or '-'}")        log("Konta: " + (", ".join(u.nazwa for u in uzytkownicy) or "brak"))        katalog_tmp = tempfile.mkdtemp(prefix="jablonski-optymalizator-", dir="/var/tmp")        k = Kontekst(numlock=numlock, uzytkownicy=uzytkownicy, sprzet=sprzet,                     katalog_tmp=katalog_tmp, nazwa=nazwa, klucz=klucz,                     logitech=[u for u in (logitech or []) if u in LOGITECH], gry=gry)        k.opcje = [o for o in (OPCJE_PROGRAMU if opcje is None else opcje) if o in OPCJE_PROGRAMU]        if "gry" not in k.opcje:            k.gry = False        k.logitech = [u for u in k.logitech if u in k.opcje]     # tylko urządzenia z pakietu        log(f"Pakiet: {nazwa_pakietu(k.opcje)} ({', '.join(k.opcje) or 'standard'}) | Logitech: "            + (", ".join(k.logitech) or "brak") + " | gry: " + ("tak" if k.gry else "nie"))        k.nvidia_rtx = nvidia_rtx and "nvidia_rtx" in k.opcje        k.antykradziez = antykradziez and "antykradziez" in k.opcje        k.grafika = {n: a for n, a in (grafika or {}).items() if n in GRAFIKA_Z_SERWERA.values()}        if k.grafika:            log("Grafika z panelu: " + ", ".join(f"{n}={a}" for n, a in k.grafika.items()))        k.flagi["do_usuniecia"] = dodatki_do_usuniecia(k.opcje, k.gry, k.logitech, k.nvidia_rtx)        if k.flagi["do_usuniecia"]:            log("Do usunięcia: " + ", ".join(k.flagi["do_usuniecia"]))        blokada = zablokuj_usypianie_systemu()        try:            licznik = wykonaj_kroki(k)        finally:            if blokada:                blokada.terminate()        return 0 if licznik["blad"] == 0 else 2    except Exception as e:   # noqa: BLE001        log(traceback.format_exc())        RAPORT.zdarzenie({"typ": "koniec", "uwagi": [f"Nieoczekiwany błąd: {e}"],                          "podsumowanie": {"ok": 0, "ostrzezenie": 0, "blad": 1, "pominiety": 0}})        return 3# ============================================================================# 7. TRYB TEKSTOWY# ============================================================================def pytanie_tak_nie(tresc: str) -> bool:    while True:        odp = input(f"{tresc} [t/n]: ").strip().lower()        if odp in ("t", "tak", "y", "yes"):            return True        if odp in ("n", "nie", "no"):            return Falsedef sprawdz_system_w_terminalu(args) -> bool:    """Brak KDE – koniec. Nie Debian 13 – ostrzeżenie i świadome potwierdzenie słowem TAK.    Ustawia args.ryzyko po potwierdzeniu. W symulacji tylko informuje."""    if args.ryzyko:        return True    if not jest_kde():        print("\n" + textwrap.fill("!!! " + TEKST_BRAK_KDE, 88))        if not args.symulacja:            return False    if not jest_debian13():        print(f"\n!!! UWAGA: wykryto {nazwa_systemu()}, a nie Debiana 13.")        print(textwrap.fill(TEKST_RYZYKO, 88))        if args.symulacja:            return True        if not sys.stdin.isatty():            return False        if input("Aby mimo to kontynuować na własne ryzyko, wpisz TAK: ").strip() != "TAK":            print("Przerwano – nic nie zostało zmienione.")            return False        args.ryzyko = True    return Truedef aktywacja_w_terminalu(nazwa: str) -> Optional[Tuple[str, List[str]]]:    """Pytanie o kod aktywacyjny w trybie tekstowym (3 próby). Zwraca (kod, opcje)."""    podpowiedz = None    try:        podpowiedz = licencja_dla_komputera(nazwa)    except (urllib.error.URLError, OSError) as e:        print(f"Nie udało się sprawdzić licencji komputera ({e}).")    if podpowiedz:        print(f"Znaleziono licencję przypisaną do „{nazwa}”: {podpowiedz}")    for _ in range(3):        if podpowiedz:            wpis = input(f"Kod aktywacyjny [{podpowiedz}]: ").strip() or podpowiedz        else:            wpis = input("Kod aktywacyjny (np. A4VC-7GW1-KJDC): ").strip()        klucz = normalizuj_klucz(wpis)        if not klucz:            print("Kod ma 12 znaków: wielkie litery i cyfry, np. A4VC-7GW1-KJDC.")            continue        ok, komunikat, opcje = aktywuj_licencje(klucz, nazwa)        print(komunikat)        if ok:            return klucz, opcje    print("Nie aktywowano programu – nic nie zostało zmienione.")    return NoneTEKST_ANTYKRADZIEZY = (    "J.K. Anty-Kradzież – zalecamy włączyć.\n\n"    "Jeśli komputer zostanie skradziony albo go zgubisz, zablokujesz go na stronie Optymalizatora "    "(przycisk „J.K. Anty-Kradzież”) albo u nas w firmie. Przy najbliższym połączeniu z internetem "    "komputer się zablokuje: nikt nie zaloguje się na żadne konto, a na ekranie zobaczy tylko "    "Twoją wiadomość dla znalazcy (np. numer telefonu) i przycisk „Wyłącz komputer”. "    "Złodziej nie zaloguje się do Twojego komputera.\n\n"    "Gdy komputer się odnajdzie – odblokujesz go na tej samej stronie i wszystko wróci dokładnie do stanu sprzed blokady "    "(te same hasła, pliki i programy).\n\n"    "Blokada działa wyłącznie po Twoim zgłoszeniu. Nie śledzimy komputera i nie widzimy Twoich plików – "    "komputer co 10 minut tylko pyta nasz serwer, czy nie został zgłoszony (serwer widzi przy tym adres "    "internetowy, co może pomóc w odnalezieniu). Zdanie możesz zmienić w każdej chwili, uruchamiając "    "Optymalizator ponownie.")TEKST_NVIDIA_RTX = (    "nVidia Unlock RTX – Twoja karta ({karta}) może liczyć AI szybciej.\n\n"    "NVIDIA fabrycznie ogranicza w kartach GeForce RTX 20/30/40 szybkość rdzeni Tensor. "    "Eksperymentalne narzędzie nv-uefi-unlocker zdejmuje to ograniczenie przed startem systemu: "    "lokalne modele językowe, generowanie obrazów i inne obliczenia AI mogą działać nawet "    "1,5–2 razy szybciej. GIER NIE PRZYSPIESZA.\n\n"    "Jak to działa: w menu startowym pojawi się osobna pozycja – wybierasz ją tylko wtedy, gdy "    "chcesz; zwykły start zostaje bez zmian. Odblokowanie trwa do wyłączenia komputera. "    "Wymaga wyłączonego Secure Boot.\n\n"    "Ryzyko: to nieoficjalne narzędzie. Na niektórych kartach może pojawić się czarny ekran albo "    "zawieszenie – wtedy wyłącz komputer przyciskiem zasilania i uruchom zwykłą pozycję „Debian”. "    "Jabłoński KOMPUTERY nie odpowiada za skutki jego użycia.")def napisz_bezpiecznie(tekst: str = "") -> None:    """print, który nie wywraca programu, gdy okno Konsoli zostało już zamknięte."""    try:        print(tekst, flush=True)    except OSError:        passdef nie_zamykaj_konsoli(okno: bool = True) -> None:    """Wyraźna informacja w Konsoli: nie zamykać okna i nie korzystać z komputera.    Dodatkowo program przestaje reagować na zamknięcie okna Konsoli (SIGHUP)."""    try:        signal.signal(signal.SIGHUP, signal.SIG_IGN)    except (ValueError, OSError):        pass    if not sys.stdout.isatty() or os.environ.get("JK_KOMUNIKAT_KONSOLI"):        return    os.environ["JK_KOMUNIKAT_KONSOLI"] = "1"            # tylko raz (program uruchamia się ponownie)    kolor = "\033[1;38;5;208m" if os.environ.get("TERM", "dumb") != "dumb" else ""    reset = "\033[0m" if kolor else ""    linie = [        "WAŻNE – PRZECZYTAJ:",        "",        "1. NIE ZAMYKAJ tego okna Konsoli, dopóki Optymalizator nie skończy pracy.",        "2. NIE KORZYSTAJ w tym czasie z komputera – nie uruchamiaj innych programów,",        "   niczego nie instaluj, nie wyłączaj komputera i nie odłączaj internetu.",        ("3. Postęp widać w oknie Optymalizatora. Gdy pokaże ekran „Gotowe”, możesz"         if okno else "3. Postęp widać poniżej. Gdy pojawi się „Zakończono”, możesz"),        "   zamknąć to okno i uruchomić komputer ponownie.",        "",        "Instalacja trwa zwykle od kilkunastu minut do godziny.",    ]    szer = max(len(l) for l in linie) + 4    napisz_bezpiecznie("\n" + kolor + "╔" + "═" * szer + "╗")    for l in linie:        napisz_bezpiecznie("║  " + l.ljust(szer - 2) + "║")    napisz_bezpiecznie("╚" + "═" * szer + "╝" + reset + "\n")def uruchom_tryb_tekstowy(args) -> int:    if os.geteuid() != 0 and not args.symulacja:        print("Tryb tekstowy wymaga uprawnień administratora:\n"              f"  sudo python3 {os.path.abspath(__file__)}\n"              "albo uruchom bez sudo, aby otworzyć okno programu.")        return 1    print("=" * 90 + f"\n  {NAZWA_PROGRAMU}\n" + "=" * 90)    nie_zamykaj_konsoli(okno=False)    if not sprawdz_system_w_terminalu(args):        return 1    domyslna = obecna_nazwa_komputera()    while True:        nazwa = input(f"\nJak ma się nazywać ten komputer? [{domyslna}]: ").strip() or domyslna        if nazwa_hosta(nazwa):            break        print("Nazwa musi zawierać litery lub cyfry.")    print(f"Nazwa w sieci: {nazwa_hosta(nazwa)}")    aktywacja = ("", list(OPCJE_PROGRAMU)) if args.symulacja else aktywacja_w_terminalu(nazwa)    if aktywacja is None:        return 1    klucz, opcje = aktywacja    print(f"\nPAKIET: {nazwa_pakietu(opcje)}" + ("  •  SECURITY BY J.K." if "antykradziez" in opcje else ""))    print("\nCO ZMIENI TEN PROGRAM:")    print(opis_zmian_tekst(wykryj_sprzet(), nazwa, opcje))    print()    if not pytanie_tak_nie("Czy rozpocząć wprowadzanie powyższych zmian?"):        print("Przerwano – nic nie zostało zmienione.")        return 0    # Pytamy tylko o to, czego program nie może ustalić sam: Num Lock – tylko w laptopie    # (komputer stacjonarny ma klawiaturę numeryczną), gry i Logitech wynikają z pakietu.    numlock = pytanie_tak_nie("Czy ten laptop ma klawiaturę numeryczną?") \        if wykryj_sprzet().laptop else True    gry = "gry" in opcje    logitech = [id_ for id_ in LOGITECH if id_ in opcje]    antykradziez = False    if "antykradziez" in opcje:        print("\n" + TEKST_ANTYKRADZIEZY)        antykradziez = pytanie_tak_nie("Czy włączyć J.K. Anty-Kradzież? (zalecamy: t)")    nvidia_rtx = False    karta_rtx = karta_rtx_do_odblokowania(wykryj_sprzet()) if "nvidia_rtx" in opcje else None    if karta_rtx:        print("\n" + TEKST_NVIDIA_RTX.format(karta=nazwa_karty(karta_rtx[0])))        nvidia_rtx = pytanie_tak_nie("Czy chcesz włączyć nVidia Unlock RTX NA WŁASNE RYZYKO?")    uzytkownik = (args.uzytkownik or os.environ.get("SUDO_USER")                  or (znajdz_uzytkownika_sesji() or Uzytkownik("", 0, 0, "")).nazwa or None)    return uruchom_wykonawce(numlock, uzytkownik, "konsola", nazwa, args.ryzyko, klucz, logitech, gry,                             opcje, nvidia_rtx, antykradziez, dict(OSTATNIA_GRAFIKA))# ============================================================================# 8. OKNO GRAFICZNE (PyQt6)# ============================================================================def utworz_okno_gui(args):    """Tworzy aplikację Qt i okno główne. Zwraca (app, okno)."""    from PyQt6.QtCore import QObject, QPointF, QProcess, QRectF, QSize, Qt, QTimer, pyqtSignal    from PyQt6.QtGui import (QBrush, QColor, QFont, QIcon, QLinearGradient, QPainter,                             QPainterPath, QPalette, QPen, QPixmap)    from PyQt6.QtWidgets import (QApplication, QCheckBox, QHBoxLayout, QHeaderView, QLabel,                                 QLineEdit, QMainWindow, QMessageBox, QPlainTextEdit, QProgressBar,                                 QPushButton, QStackedWidget, QTextBrowser, QTreeWidget,                                 QTreeWidgetItem, QVBoxLayout, QWidget)    # --- Kolory i styl -----------------------------------------------------------    # Kolory marki Jabłoński KOMPUTERY – odcienie pomarańczu    KOLOR_GLOWNY, KOLOR_JASNY = "#e65100", "#ffa000"    KOLOR_STANU = {"oczekuje": "#cfc2b8", "trwa": "#f57c00", "ok": "#2e7d32",                   "ostrzezenie": "#b26a00", "blad": "#c62828", "pominiety": "#a1918a"}    OPIS_STANU = {"oczekuje": "oczekuje", "trwa": "w toku…", "ok": "gotowe",                  "ostrzezenie": "z uwagami", "blad": "błąd", "pominiety": "pominięto"}    STYL = f"""        QWidget#strona {{ background: #fdf8f4; }}        QLabel#tytul {{ font-size: 17pt; font-weight: 600; color: #2b2522; }}        QLabel#podtytul {{ color: #6d5d52; font-size: 10.5pt; }}        QLabel#biezacy {{ color: {KOLOR_GLOWNY}; font-weight: 600; font-size: 11pt; }}        QLabel#stopka {{ color: #9e8c80; font-size: 9pt; }}        QPushButton {{ padding: 8px 18px; border-radius: 6px; border: 1px solid #e3cbb8;                      background: white; color: #2b2522; font-size: 10.5pt; }}        QPushButton:hover {{ background: #fdeee2; }}        QPushButton#akcent {{ background: {KOLOR_GLOWNY}; color: white; border: none; font-weight: 600; }}        QPushButton#akcent:hover {{ background: #bf360c; }}        QPushButton#akcent:disabled {{ background: #f0b98a; }}        QPushButton#duzy {{ padding: 16px 22px; font-size: 12.5pt; font-weight: 600; }}        QPushButton#link {{ border: none; background: transparent; color: {KOLOR_GLOWNY}; padding: 4px; }}        QTextBrowser, QTreeWidget {{ background: white; border: 1px solid #f1dfd0;                                    border-radius: 8px; padding: 6px; color: #2b2522; }}        QTreeWidget::item {{ padding: 4px 2px; }}        QProgressBar {{ border: none; background: #f1dfd0; border-radius: 8px; min-height: 16px;                       text-align: center; color: #2b2522; font-weight: 600; }}        QProgressBar::chunk {{ border-radius: 8px; background: qlineargradient(x1:0, y1:0, x2:1,                              y2:0, stop:0 {KOLOR_GLOWNY}, stop:1 {KOLOR_JASNY}); }}        QPlainTextEdit#dziennik {{ background: #2b2522; color: #f1dfd0; border-radius: 8px;                                   font-family: monospace; font-size: 9pt; padding: 6px; }}        QCheckBox {{ color: #2b2522; font-size: 10.5pt; }}        QLineEdit {{ padding: 10px 12px; font-size: 15pt; border: 1px solid #e3cbb8;                    border-radius: 8px; background: white; color: #2b2522; }}        QLineEdit:focus {{ border: 2px solid {KOLOR_GLOWNY}; }}    """    # --- Grafiki rysowane w kodzie (nie zależą od motywu ikon) ---------------------------    def ikona_stanu(stan: str, kat: int = 0, rozmiar: int = 22) -> QIcon:        pix = QPixmap(rozmiar, rozmiar)        pix.fill(Qt.GlobalColor.transparent)        p = QPainter(pix)        p.setRenderHint(QPainter.RenderHint.Antialiasing)        kolor = QColor(KOLOR_STANU.get(stan, "#a1918a"))        r = QRectF(2, 2, rozmiar - 4, rozmiar - 4)        if stan == "oczekuje":            p.setPen(QPen(kolor, 2))            p.drawEllipse(r)        elif stan == "trwa":            p.setPen(QPen(QColor("#f1dfd0"), 3))            p.drawEllipse(r)            p.setPen(QPen(kolor, 3, cap=Qt.PenCapStyle.RoundCap))            p.drawArc(r, -kat * 16, 100 * 16)        else:            p.setPen(Qt.PenStyle.NoPen)            p.setBrush(kolor)            p.drawEllipse(r)            p.setPen(QPen(QColor("white"), max(2.4, rozmiar * 0.11), cap=Qt.PenCapStyle.RoundCap,                          join=Qt.PenJoinStyle.RoundJoin))            s = rozmiar            if stan == "ok":                sciezka = QPainterPath(QPointF(s * .28, s * .52))                sciezka.lineTo(QPointF(s * .44, s * .67))                sciezka.lineTo(QPointF(s * .72, s * .36))                p.drawPath(sciezka)            elif stan == "ostrzezenie":                p.drawLine(QPointF(s / 2, s * .27), QPointF(s / 2, s * .58))                p.drawPoint(QPointF(s / 2, s * .74))            elif stan == "blad":                p.drawLine(QPointF(s * .33, s * .33), QPointF(s * .67, s * .67))                p.drawLine(QPointF(s * .67, s * .33), QPointF(s * .33, s * .67))            else:                p.drawLine(QPointF(s * .32, s / 2), QPointF(s * .68, s / 2))        p.end()        return QIcon(pix)    def logo(rozmiar: int = 64, tlo_biale: bool = False) -> QPixmap:        pix = QPixmap(rozmiar, rozmiar)        pix.fill(Qt.GlobalColor.transparent)        p = QPainter(pix)        p.setRenderHint(QPainter.RenderHint.Antialiasing)        r = QRectF(1, 1, rozmiar - 2, rozmiar - 2)        if tlo_biale:            p.setBrush(QColor("white"))        else:            g = QLinearGradient(0, 0, rozmiar, rozmiar)            g.setColorAt(0, QColor(KOLOR_GLOWNY))            g.setColorAt(1, QColor(KOLOR_JASNY))            p.setBrush(QBrush(g))        p.setPen(Qt.PenStyle.NoPen)        p.drawRoundedRect(r, rozmiar * .22, rozmiar * .22)        f = QFont()        f.setBold(True)        f.setPixelSize(int(rozmiar * .42))        p.setFont(f)        p.setPen(QColor(KOLOR_GLOWNY if tlo_biale else "white"))        p.drawText(r, Qt.AlignmentFlag.AlignCenter, "JK")        p.end()        return pix    def obraz_klawiatury(wlaczony: bool) -> QPixmap:        """Rysunek bloku numerycznego z diodą Num Lock."""        klawisz, odstep, margines, gora = 36, 6, 14, 30        szer = margines * 2 + 4 * klawisz + 3 * odstep        wys = margines * 2 + gora + 5 * klawisz + 4 * odstep        pix = QPixmap(szer, wys)        pix.fill(Qt.GlobalColor.transparent)        p = QPainter(pix)        p.setRenderHint(QPainter.RenderHint.Antialiasing)        p.setPen(QPen(QColor("#f0b98a"), 1.5))        p.setBrush(QColor("#fbeee4"))        p.drawRoundedRect(QRectF(1, 1, szer - 2, wys - 2), 14, 14)        dioda = QColor("#43a047") if wlaczony else QColor("#cfc2b8")        p.setPen(Qt.PenStyle.NoPen)        p.setBrush(dioda)        p.drawEllipse(QPointF(margines + 8, margines + 9), 6, 6)        f = QFont()        f.setPixelSize(12)        f.setBold(True)        p.setFont(f)        p.setPen(QColor("#6d5d52"))        p.drawText(QRectF(margines + 20, margines, 120, 18), Qt.AlignmentFlag.AlignVCenter,                   "Num Lock " + ("wł." if wlaczony else "wył."))        klawisze = [(0, 0, 1, 1, "Num"), (1, 0, 1, 1, "/"), (2, 0, 1, 1, "*"), (3, 0, 1, 1, "−"),                    (0, 1, 1, 1, "7"), (1, 1, 1, 1, "8"), (2, 1, 1, 1, "9"), (3, 1, 1, 2, "+"),                    (0, 2, 1, 1, "4"), (1, 2, 1, 1, "5"), (2, 2, 1, 1, "6"),                    (0, 3, 1, 1, "1"), (1, 3, 1, 1, "2"), (2, 3, 1, 1, "3"), (3, 3, 1, 2, "↵"),                    (0, 4, 2, 1, "0"), (2, 4, 1, 1, ",")]        for kol, wiersz, w, h, napis in klawisze:            x = margines + kol * (klawisz + odstep)            y = margines + gora + wiersz * (klawisz + odstep)            prost = QRectF(x, y, w * klawisz + (w - 1) * odstep, h * klawisz + (h - 1) * odstep)            p.setPen(QPen(QColor("#f0b98a"), 1))            p.setBrush(QColor("#ffffff") if napis != "Num" else                       (QColor("#c8e6c9") if wlaczony else QColor("#ffffff")))            p.drawRoundedRect(prost, 6, 6)            f.setPixelSize(13 if napis == "Num" else 16)            p.setFont(f)            p.setPen(QColor("#2b2522"))            p.drawText(prost, Qt.AlignmentFlag.AlignCenter, napis)        p.end()        return pix    def ikona_tarczy() -> QIcon:        """Biała tarcza z ptaszkiem – przycisk „Tak, włącz ochronę”."""        pix = QPixmap(52, 52)        pix.fill(Qt.GlobalColor.transparent)        p = QPainter(pix)        p.setRenderHint(QPainter.RenderHint.Antialiasing)        p.setPen(Qt.PenStyle.NoPen)        p.setBrush(QColor("white"))        tarcza = QPainterPath()        tarcza.moveTo(26, 4)        tarcza.lineTo(45, 11)        tarcza.cubicTo(45, 30, 38, 41, 26, 48)        tarcza.cubicTo(14, 41, 7, 30, 7, 11)        tarcza.closeSubpath()        p.drawPath(tarcza)        pioro = QPen(QColor(KOLOR_GLOWNY), 5)        pioro.setCapStyle(Qt.PenCapStyle.RoundCap)        pioro.setJoinStyle(Qt.PenJoinStyle.RoundJoin)        p.setPen(pioro)        p.drawPolyline([QPointF(17, 26), QPointF(24, 33), QPointF(36, 19)])        p.end()        return QIcon(pix)    def obraz_komputera() -> QPixmap:        """Rysunek monitora z logo – ilustracja pytania o nazwę komputera."""        pix = QPixmap(200, 160)        pix.fill(Qt.GlobalColor.transparent)        p = QPainter(pix)        p.setRenderHint(QPainter.RenderHint.Antialiasing)        p.setPen(Qt.PenStyle.NoPen)        p.setBrush(QColor("#4e342e"))        p.drawRoundedRect(QRectF(6, 4, 188, 118), 12, 12)        g = QLinearGradient(0, 0, 200, 130)        g.setColorAt(0, QColor(KOLOR_GLOWNY))        g.setColorAt(1, QColor(KOLOR_JASNY))        p.setBrush(QBrush(g))        p.drawRoundedRect(QRectF(14, 12, 172, 102), 6, 6)        p.setBrush(QColor("#9e8c80"))        p.drawRect(QRectF(88, 122, 24, 18))        p.drawRoundedRect(QRectF(58, 138, 84, 12), 5, 5)        f = QFont()        f.setBold(True)        f.setPixelSize(34)        p.setFont(f)        p.setPen(QColor("white"))        p.drawText(QRectF(14, 12, 172, 102), Qt.AlignmentFlag.AlignCenter, "JK")        p.end()        return pix    def obraz_klucza() -> QPixmap:        """Rysunek klucza – ilustracja strony aktywacji."""        pix = QPixmap(220, 120)        pix.fill(Qt.GlobalColor.transparent)        p = QPainter(pix)        p.setRenderHint(QPainter.RenderHint.Antialiasing)        g = QLinearGradient(0, 0, 220, 120)        g.setColorAt(0, QColor(KOLOR_GLOWNY))        g.setColorAt(1, QColor(KOLOR_JASNY))        p.setPen(Qt.PenStyle.NoPen)        p.setBrush(QBrush(g))        p.drawEllipse(QRectF(10, 15, 90, 90))                     # główka        p.drawRoundedRect(QRectF(85, 50, 125, 20), 6, 6)          # trzon        p.drawRect(QRectF(160, 68, 14, 26))                       # ząbki        p.drawRect(QRectF(185, 68, 14, 18))        p.setBrush(QColor("#fdf8f4"))        p.drawEllipse(QRectF(35, 40, 40, 40))                     # otwór        p.end()        return pix    class Zadanie(QObject):        """Uruchamia funkcję w osobnym wątku (zapytania do serwera nie blokują okna)        i oddaje wynik sygnałem w wątku okna. Wyjątek jest przekazywany jako wynik."""        gotowe = pyqtSignal(object)        def __init__(self, funkcja, *argumenty):            super().__init__()            self.funkcja, self.argumenty = funkcja, argumenty        def start(self):            threading.Thread(target=self._praca, daemon=True).start()        def _praca(self):            try:                wynik = self.funkcja(*self.argumenty)            except Exception as e:        # noqa: BLE001 – wynik obsłuży okno                wynik = e            self.gotowe.emit(wynik)    def duza_ikona(stan: str) -> QPixmap:        return ikona_stanu(stan, rozmiar=72).pixmap(72, 72)    # --- Widżety -----------------------------------------------------------------------    class Naglowek(QWidget):        """Pasek z gradientem, logo i nazwą programu."""        def __init__(self):            super().__init__()            self.setFixedHeight(100)            self.pakiet = ""                      # STANDARD / OFFICE / GAMING / PROFESSIONAL            self.ochrona = False                  # opcja „Anty-kradzież” w pakiecie → SECURITY BY J.K.        def ustaw_pakiet(self, pakiet: str, ochrona: bool = False):            self.pakiet = pakiet            self.ochrona = ochrona            self.update()        def paintEvent(self, _zdarzenie):            p = QPainter(self)            p.setRenderHint(QPainter.RenderHint.Antialiasing)            r = self.rect()            g = QLinearGradient(0, 0, r.width(), r.height())            g.setColorAt(0, QColor(KOLOR_GLOWNY))            g.setColorAt(1, QColor(KOLOR_JASNY))            p.fillRect(r, QBrush(g))            p.setPen(Qt.PenStyle.NoPen)            p.setBrush(QColor(255, 255, 255, 22))            p.drawEllipse(QPointF(r.width() - 70, 8), 95, 95)            p.drawEllipse(QPointF(r.width() - 200, r.height() + 25), 65, 65)            p.setBrush(QColor(255, 255, 255, 12))            p.drawEllipse(QPointF(r.width() * .55, -30), 70, 70)            p.drawPixmap(22, 18, logo(64, tlo_biale=True))            f = QFont(self.font())            f.setBold(True)            f.setPointSize(19)            p.setFont(f)            p.setPen(QColor("white"))            p.drawText(QRectF(104, 16, r.width() - 120, 36),                       Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter, "Optymalizator")            f.setBold(False)            f.setPointSize(10)            p.setFont(f)            p.setPen(QColor(255, 255, 255, 225))            p.drawText(QRectF(105, 54, r.width() - 120, 22),                       Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter,                       "Jabłoński KOMPUTERY  •  www.k.j.pl  •  Debian 13 z KDE Plasma")            if self.pakiet:                       # znaczek pakietu po prawej                f.setBold(True)                f.setPointSize(12)                f.setLetterSpacing(QFont.SpacingType.PercentageSpacing, 112)                p.setFont(f)                szer = p.fontMetrics().horizontalAdvance(self.pakiet) + 34                ramka = QRectF(r.width() - szer - 24, (r.height() - 36) / 2, szer, 36)                p.setPen(Qt.PenStyle.NoPen)                p.setBrush(QColor("white"))                p.drawRoundedRect(ramka, 18, 18)                p.setPen(QColor(KOLOR_GLOWNY))                p.drawText(ramka, Qt.AlignmentFlag.AlignCenter, self.pakiet)                if self.ochrona:                  # obok: SECURITY BY J.K. (biała ramka, tarcza)                    napis = "SECURITY BY J.K."                    szer2 = p.fontMetrics().horizontalAdvance(napis) + 58                    ramka2 = QRectF(ramka.left() - szer2 - 10, ramka.top(), szer2, 36)                    p.setPen(QPen(QColor("white"), 2))                    p.setBrush(QColor(255, 255, 255, 40))                    p.drawRoundedRect(ramka2.adjusted(1, 1, -1, -1), 17, 17)                    x, y = ramka2.left() + 16, ramka2.top() + 8          # tarcza z ptaszkiem                    tarcza = QPainterPath()                    tarcza.moveTo(x + 8, y)                    tarcza.lineTo(x + 16, y + 3)                    tarcza.cubicTo(x + 16, y + 12, x + 13, y + 17, x + 8, y + 20)                    tarcza.cubicTo(x + 3, y + 17, x, y + 12, x, y + 3)                    tarcza.closeSubpath()                    p.setPen(Qt.PenStyle.NoPen)                    p.setBrush(QColor("white"))                    p.drawPath(tarcza)                    pioro = QPen(QColor(KOLOR_GLOWNY), 2.2)                    pioro.setCapStyle(Qt.PenCapStyle.RoundCap)                    p.setPen(pioro)                    p.drawPolyline([QPointF(x + 4.5, y + 10), QPointF(x + 7.5, y + 13), QPointF(x + 12, y + 7)])                    p.setPen(QColor("white"))                    p.drawText(ramka2.adjusted(26, 0, 0, 0), Qt.AlignmentFlag.AlignCenter, napis)            p.end()    def strona_bazowa() -> Tuple[QWidget, QVBoxLayout]:        w = QWidget()        w.setObjectName("strona")        uklad = QVBoxLayout(w)        uklad.setContentsMargins(26, 20, 26, 18)        uklad.setSpacing(12)        return w, uklad    def etykieta(tekst: str, nazwa: str = "", zawijanie: bool = True) -> QLabel:        e = QLabel(tekst)        if nazwa:            e.setObjectName(nazwa)        e.setWordWrap(zawijanie)        return e    def przycisk(tekst: str, nazwa: str = "") -> QPushButton:        b = QPushButton(tekst)        if nazwa:            b.setObjectName(nazwa)        b.setCursor(Qt.CursorShape.PointingHandCursor)        return b    # --- Okno główne ---------------------------------------------------------------------    class OknoGlowne(QMainWindow):        def __init__(self, sprzet: Sprzet):            super().__init__()            self.args = args            self.sprzet = sprzet            self.proces: Optional[QProcess] = None            self.bufor = ""            self.trwa = False            self.zakonczono = False            self.otrzymano_zdarzenia = False            self.elementy: Dict[str, QTreeWidgetItem] = {}            self.biezacy: Optional[str] = None            self.kat = 0            self.zegar = QTimer(self)            self.zegar.timeout.connect(self._obroc_wskaznik)            self.setWindowTitle(NAZWA_PROGRAMU)            self.setWindowIcon(QIcon(logo(64)))            self.resize(940, 760)            srodek = QWidget()            uklad = QVBoxLayout(srodek)            uklad.setContentsMargins(0, 0, 0, 0)            uklad.setSpacing(0)            self.naglowek = Naglowek()            uklad.addWidget(self.naglowek)            self.stos = QStackedWidget()            uklad.addWidget(self.stos, 1)            self.setCentralWidget(srodek)            self.nazwa = obecna_nazwa_komputera()            self.ryzyko = bool(getattr(args, "ryzyko", False))            self.strona_brak_kde = self._zbuduj_strone_brak_kde()            self.strona_ryzyko = self._zbuduj_strone_ryzyka()            self.strona_nazwa = self._zbuduj_strone_nazwy()            self.klucz = ""                       # aktywowany kod            self.opcje: List[str] = list(OPCJE_PROGRAMU)   # opcje z licencji (pakiet)            self.aktywowano_dla: Optional[Tuple[str, str]] = None   # (klucz, nazwa)            self.zadania: List[QObject] = []      # trzymamy referencje do zadań w tle            self.strona_aktywacja = self._zbuduj_strone_aktywacji()            self.strona_opis = self._zbuduj_strone_opisu()            self.strona_numlock = self._zbuduj_strone_numlock()            self.strona_logitech = self._zbuduj_strone_logitech()            self.strona_nvidia = self._zbuduj_strone_nvidia()            self.wybrane_nvidia = False            self.strona_antykradziezy = self._zbuduj_strone_antykradziezy()            self.wybrana_ochrona = False            self.wybrany_numlock = True            self.wybrane_gry = True            self.strona_postep = self._zbuduj_strone_postepu()            self.strona_koniec = self._zbuduj_strone_konca()            for s in (self.strona_brak_kde, self.strona_ryzyko, self.strona_nazwa, self.strona_aktywacja, self.strona_opis, self.strona_numlock, self.strona_logitech, self.strona_nvidia,                         self.strona_antykradziezy,                      self.strona_postep, self.strona_koniec):                self.stos.addWidget(s)            # strona startowa zależy od systemu (w symulacji sprawdzenie tylko informuje)            if not self.sprzet.kde and not args.symulacja:                self.stos.setCurrentWidget(self.strona_brak_kde)            elif not self.sprzet.debian13 and not self.ryzyko and not args.symulacja:                self.stos.setCurrentWidget(self.strona_ryzyko)            else:                self.stos.setCurrentWidget(self.strona_nazwa)        def _strona_komunikatu(self, stan: str, tytul: str, tekst: str):            w, u = strona_bazowa()            gora = QHBoxLayout()            ikona = QLabel()            ikona.setPixmap(duza_ikona(stan))            gora.addWidget(ikona, 0, Qt.AlignmentFlag.AlignTop)            teksty = QVBoxLayout()            teksty.addWidget(etykieta(tytul, "tytul"))            opis = etykieta(tekst, "podtytul")            opis.setStyleSheet("font-size: 12pt;")            teksty.addWidget(opis)            gora.addLayout(teksty, 1)            u.addLayout(gora)            u.addSpacing(10)            u.addWidget(etykieta(f"Wykryty system: <b>{html.escape(nazwa_systemu())}</b>", "podtytul"))            return w, u        # ----- Strona: brak KDE – programu nie można użyć -----        def _zbuduj_strone_brak_kde(self) -> QWidget:            w, u = self._strona_komunikatu("blad", "Brak pulpitu KDE Plasma", TEKST_BRAK_KDE)            u.addStretch(1)            dol = QHBoxLayout()            dol.addStretch(1)            zamknij = przycisk("Zamknij", "akcent")            zamknij.clicked.connect(self.close)            dol.addWidget(zamknij)            u.addLayout(dol)            return w        # ----- Strona: nie Debian 13 – ostrzeżenie i świadoma zgoda -----        def _zbuduj_strone_ryzyka(self) -> QWidget:            w, u = self._strona_komunikatu("ostrzezenie", "To nie jest Debian 13", TEKST_RYZYKO)            u.addSpacing(16)            zgoda = QCheckBox("Rozumiem, że program może uszkodzić ten system, i biorę za to "                              "odpowiedzialność")            u.addWidget(zgoda)            u.addStretch(1)            dol = QHBoxLayout()            dol.addStretch(1)            zamknij = przycisk("Zamknij – nie ryzykuję", "akcent")            zamknij.clicked.connect(self.close)            dalej = przycisk("Kontynuuj mimo to")            dalej.setStyleSheet("color: #c62828; border-color: #f0b4b4;")            dalej.setEnabled(False)            zgoda.toggled.connect(dalej.setEnabled)            def kontynuuj():                self.ryzyko = True                self.stos.setCurrentWidget(self.strona_nazwa)            dalej.clicked.connect(kontynuuj)            dol.addWidget(dalej)            dol.addWidget(zamknij)            u.addLayout(dol)            return w        # ----- Strona 0: nazwa komputera -----        def _zbuduj_strone_nazwy(self) -> QWidget:            w, u = strona_bazowa()            u.addWidget(etykieta("Jak ma się nazywać ten komputer?", "tytul"))            u.addWidget(etykieta(                "Ta nazwa będzie widoczna w sieci, w KDE Connect na telefonie, przez Bluetooth "                f"i w programie „{JK_NAZWA}”. Możesz użyć polskich liter i spacji – nazwa "                "sieciowa powstanie z niej automatycznie.", "podtytul"))            u.addStretch(1)            rysunek = QLabel()            rysunek.setPixmap(obraz_komputera())            rysunek.setAlignment(Qt.AlignmentFlag.AlignCenter)            u.addWidget(rysunek)            u.addSpacing(10)            wiersz = QHBoxLayout()            wiersz.addStretch(1)            self.pole_nazwy = QLineEdit(self.nazwa)            self.pole_nazwy.setMaxLength(60)            self.pole_nazwy.setMinimumWidth(460)            self.pole_nazwy.setPlaceholderText("np. Komputer Ani")            self.pole_nazwy.setAlignment(Qt.AlignmentFlag.AlignCenter)            wiersz.addWidget(self.pole_nazwy)            wiersz.addStretch(1)            u.addLayout(wiersz)            self.e_nazwa_sieciowa = etykieta("", "podtytul")            self.e_nazwa_sieciowa.setAlignment(Qt.AlignmentFlag.AlignCenter)            u.addWidget(self.e_nazwa_sieciowa)            u.addStretch(2)            dol = QHBoxLayout()            dol.addStretch(1)            zamknij = przycisk("Zamknij")            zamknij.clicked.connect(self.close)            self.dalej_nazwa = przycisk("Dalej  ›", "akcent")            self.dalej_nazwa.clicked.connect(self._po_nazwie)            self.pole_nazwy.returnPressed.connect(self._po_nazwie)            self.pole_nazwy.textChanged.connect(self._nazwa_zmieniona)            dol.addWidget(zamknij)            dol.addWidget(self.dalej_nazwa)            u.addLayout(dol)            self._nazwa_zmieniona(self.nazwa)            return w        def _nazwa_zmieniona(self, tekst: str):            host = nazwa_hosta(tekst)            self.dalej_nazwa.setEnabled(bool(host))            self.e_nazwa_sieciowa.setText(                f"Nazwa w sieci: <b>{html.escape(host)}</b>" if host else                '<span style="color:#c62828;">Wpisz nazwę zawierającą litery lub cyfry</span>')        def _po_nazwie(self):            if not nazwa_hosta(self.pole_nazwy.text()):                return            self.nazwa = self.pole_nazwy.text().strip()            self.opis.setHtml(opis_zmian_html(self.sprzet, self.nazwa, self.opcje))            self.stos.setCurrentWidget(self.strona_aktywacja)            self._sprawdz_licencje_komputera()        # ----- Strona 1: kod aktywacyjny -----        def _zbuduj_strone_aktywacji(self) -> QWidget:            w, u = strona_bazowa()            u.addWidget(etykieta("Kod aktywacyjny", "tytul"))            u.addWidget(etykieta(                "Wpisz 12-znakowy kod aktywacyjny otrzymany od Jabłoński KOMPUTERY "                "(np. A4VC-7GW1-KJDC). Jeśli ten komputer ma już przypisaną licencję, kod "                "pojawi się sam – wystarczy go sprawdzić i kliknąć „Aktywuj”.", "podtytul"))            u.addStretch(1)            rysunek = QLabel()            rysunek.setPixmap(obraz_klucza())            rysunek.setAlignment(Qt.AlignmentFlag.AlignCenter)            u.addWidget(rysunek)            u.addSpacing(10)            wiersz = QHBoxLayout()            wiersz.addStretch(1)            self.pole_klucza = QLineEdit()            # N = litera lub cyfra (wymagana), > = zamiana na wielkie litery            self.pole_klucza.setInputMask(">NNNN-NNNN-NNNN;_")            self.pole_klucza.setMinimumWidth(420)            self.pole_klucza.setAlignment(Qt.AlignmentFlag.AlignCenter)            czcionka = QFont("monospace")            czcionka.setStyleHint(QFont.StyleHint.Monospace)            czcionka.setPointSize(20)            czcionka.setBold(True)            self.pole_klucza.setFont(czcionka)            wiersz.addWidget(self.pole_klucza)            wiersz.addStretch(1)            u.addLayout(wiersz)            self.e_status_klucza = etykieta("", "podtytul")            self.e_status_klucza.setAlignment(Qt.AlignmentFlag.AlignCenter)            u.addWidget(self.e_status_klucza)            sprzet, opis_sprzetu = identyfikator_sprzetu()            e_sprzet = etykieta(f"Identyfikator komputera: {sprzet}  •  {opis_sprzetu}", "stopka")            e_sprzet.setAlignment(Qt.AlignmentFlag.AlignCenter)            e_sprzet.setTextInteractionFlags(Qt.TextInteractionFlag.TextSelectableByMouse)            u.addWidget(e_sprzet)            u.addStretch(2)            dol = QHBoxLayout()            wstecz = przycisk("‹  Wstecz")            wstecz.clicked.connect(lambda: self.stos.setCurrentWidget(self.strona_nazwa))            dol.addWidget(wstecz)            dol.addStretch(1)            self.przycisk_aktywuj = przycisk("Aktywuj  ›", "akcent")            self.przycisk_aktywuj.clicked.connect(self._aktywuj)            self.pole_klucza.returnPressed.connect(self._aktywuj)            self.pole_klucza.textChanged.connect(self._klucz_zmieniony)            dol.addWidget(self.przycisk_aktywuj)            u.addLayout(dol)            self._klucz_zmieniony()            return w        def _status_klucza(self, tekst: str, kolor: str = "#6d5d52"):            self.e_status_klucza.setText(f'<span style="color:{kolor};">{tekst}</span>')        def _klucz_zmieniony(self, *_):            self.przycisk_aktywuj.setEnabled(self.pole_klucza.hasAcceptableInput())        def _w_tle(self, funkcja, argumenty: tuple, po_zakonczeniu):            zadanie = Zadanie(funkcja, *argumenty)            zadanie.gotowe.connect(po_zakonczeniu)            zadanie.gotowe.connect(lambda _w, z=zadanie: self.zadania.remove(z))            self.zadania.append(zadanie)            zadanie.start()        def _sprawdz_licencje_komputera(self):            """?czy-jest-licencja=NAZWA – jeśli serwer zna licencję komputera, wpisujemy ją            w pole; użytkownik zatwierdza ją sam przyciskiem „Aktywuj”."""            nazwa = self.nazwa            self._status_klucza(f"Sprawdzam, czy komputer „{html.escape(nazwa)}” ma przypisaną "                                "licencję…")            def wynik(klucz):                if nazwa != self.nazwa:          # w międzyczasie zmieniono nazwę                    return                if isinstance(klucz, Exception):                    self._status_klucza("Nie udało się połączyć z serwerem licencji – sprawdź "                                        "internet. Kod możesz wpisać ręcznie.", "#c62828")                elif klucz:                    self.pole_klucza.setText(klucz)                    self._status_klucza(f"Znaleziono licencję przypisaną do „{html.escape(nazwa)}”."                                        " Sprawdź kod i kliknij „Aktywuj”.", "#2e7d32")                    self.pole_klucza.setFocus()                else:                    self._status_klucza("Ten komputer nie ma jeszcze przypisanej licencji – "                                        "wpisz kod aktywacyjny.")                    self.pole_klucza.setFocus()            self._w_tle(licencja_dla_komputera, (nazwa,), wynik)        def _aktywuj(self):            if not self.pole_klucza.hasAcceptableInput():                return            klucz, nazwa = self.pole_klucza.text(), self.nazwa            if self.aktywowano_dla == (klucz, nazwa):     # już aktywowany w tej sesji                self.stos.setCurrentWidget(self.strona_opis)                return            self.przycisk_aktywuj.setEnabled(False)            self._status_klucza("Sprawdzam kod aktywacyjny…")            def wynik(odp):                self._klucz_zmieniony()                ok, komunikat, opcje = odp if isinstance(odp, tuple) else (False, str(odp), [])                if not ok and self.args.symulacja:                    ok, komunikat = True, "Symulacja – licencja nie jest wymagana."                    opcje = list(OPCJE_PROGRAMU)                if ok:                    self.klucz, self.aktywowano_dla = klucz, (klucz, nazwa)                    self.opcje = opcje                    self.naglowek.ustaw_pakiet(nazwa_pakietu(opcje), "antykradziez" in opcje)                    self.opis.setHtml(opis_zmian_html(self.sprzet, self.nazwa, self.opcje))                    self._status_klucza(komunikat, "#2e7d32")                    self.stos.setCurrentWidget(self.strona_opis)                else:                    self._status_klucza(html.escape(komunikat), "#c62828")            self._w_tle(aktywuj_licencje, (klucz, nazwa), wynik)        # ----- Strona 1: co zmieni program -----        def _zbuduj_strone_opisu(self) -> QWidget:            w, u = strona_bazowa()            u.addWidget(etykieta("Wszystko ustawimy za Ciebie", "tytul"))            u.addWidget(etykieta(                "Nic nie musisz wybierać ani ustawiać – nasi technicy przygotowali wszystko "                "wcześniej. Poniżej jest pełna lista zmian, gdyby ktoś chciał zajrzeć. "                "Kliknij „Dalej”, a resztę zrobimy sami.", "podtytul"))            self.opis = QTextBrowser()            self.opis.setHtml(opis_zmian_html(self.sprzet, self.nazwa))            u.addWidget(self.opis, 1)            dol = QHBoxLayout()            if self.args.symulacja:                dol.addWidget(etykieta("TRYB SYMULACJI – nic nie zostanie zmienione", "stopka"))            dol.addStretch(1)            anuluj = przycisk("‹  Wstecz")            anuluj.clicked.connect(lambda: self.stos.setCurrentWidget(self.strona_aktywacja))            self.dalej = przycisk("Dalej  ›", "akcent")            self.dalej.setDefault(True)            self.dalej.clicked.connect(self._po_opisie)            dol.addWidget(anuluj)            dol.addWidget(self.dalej)            u.addLayout(dol)            return w        # ----- Strona 2: pytanie o klawiaturę numeryczną -----        def _zbuduj_strone_numlock(self) -> QWidget:            w, u = strona_bazowa()            u.addWidget(etykieta("Czy ten laptop ma klawiaturę numeryczną?", "tytul"))            u.addWidget(etykieta(                "Klawiatura numeryczna to blok klawiszy z cyframi 0–9 po prawej stronie "                "klawiatury. Jeśli jest – Num Lock będzie włączony od razu, już na ekranie "                "logowania. Jeśli jej nie ma – Num Lock zostanie wyłączony, "                "bo na takich laptopach zamienia część liter w cyfry.", "podtytul"))            u.addStretch(1)            obrazy = QHBoxLayout()            obrazy.addStretch(1)            for wlaczony, tekst in ((True, "✔  Tak, mam klawiaturę numeryczną"),                                    (False, "✖  Nie mam")):                kolumna = QVBoxLayout()                kolumna.setSpacing(14)                obraz = QLabel()                obraz.setPixmap(obraz_klawiatury(wlaczony))                obraz.setAlignment(Qt.AlignmentFlag.AlignCenter)                kolumna.addWidget(obraz)                b = przycisk(tekst, "duzy")                if wlaczony:                    b.setStyleSheet(f"background: {KOLOR_GLOWNY}; color: white; border: none;")                b.setMinimumWidth(270)                b.clicked.connect(lambda _=False, v=wlaczony: self._po_numlock(v))                kolumna.addWidget(b)                obrazy.addLayout(kolumna)                obrazy.addSpacing(40)            obrazy.addStretch(1)            u.addLayout(obrazy)            u.addStretch(2)            dol = QHBoxLayout()            wstecz = przycisk("‹  Wstecz do listy zmian", "link")            wstecz.clicked.connect(lambda: self.stos.setCurrentWidget(self.strona_opis))            dol.addWidget(wstecz)            dol.addStretch(1)            u.addLayout(dol)            return w        # Każde pytanie to dla początkującego stres – pytamy tylko o to, czego program nie może        # ustalić sam. Gry i urządzenia Logitech wynikają z pakietu (wybrane przy zamówieniu),        # Num Lock w komputerze stacjonarnym jest zawsze włączony (jak w Windows).        def _strona_przed_pytaniami(self) -> QWidget:            return self.strona_numlock if self.sprzet.laptop else self.strona_opis        def _po_opisie(self):            if self.sprzet.laptop:                self.stos.setCurrentWidget(self.strona_numlock)            else:                self._po_numlock(True)        def _po_numlock(self, numlock: bool):            self.wybrany_numlock = numlock            self._po_grach("gry" in self.opcje)        def _po_grach(self, gry: bool):            self.wybrane_gry = gry            for id_, pole in self.pola_logitech.items():     # urządzenia z pakietu – bez pytania                pole.setChecked(id_ in self.opcje)            self._po_logitech()        def _po_logitech(self):            if "antykradziez" in self.opcje:      # pytamy tylko, gdy ochrona jest w pakiecie                self.stos.setCurrentWidget(self.strona_antykradziezy)                self.przycisk_ochrony_tak.setFocus()            else:                self.wybrana_ochrona = False                self._po_antykradziezy()        def _po_ochronie(self, tak: bool):            self.wybrana_ochrona = tak            self._po_antykradziezy()        # ----- Strona: ochrona przed kradzieżą -----        def _zbuduj_strone_antykradziezy(self) -> QWidget:            w, u = strona_bazowa()            u.addWidget(etykieta("J.K. Anty-Kradzież – ochrona przed kradzieżą", "tytul"))            opis = etykieta(TEKST_ANTYKRADZIEZY.replace("J.K. Anty-Kradzież – zalecamy włączyć.\n\n", ""),                            "podtytul")            opis.setStyleSheet("font-size: 11pt; color: #2b2522;")            u.addWidget(opis)            u.addStretch(1)            dol = QHBoxLayout()            wstecz = przycisk("‹  Wstecz", "link")            wstecz.clicked.connect(lambda: self.stos.setCurrentWidget(self._strona_przed_pytaniami()))            dol.addWidget(wstecz)            dol.addStretch(1)            nie = przycisk("Nie, dziękuję", "duzy")            nie.setStyleSheet("QPushButton { background: white; color: #6d5d52; border: 1px solid #e0cbb9; }")            nie.clicked.connect(lambda: self._po_ochronie(False))            tak = przycisk("Tak, włącz ochronę (zalecane)", "duzy")            tak.setIcon(ikona_tarczy())            tak.setIconSize(QSize(24, 24))            tak.setStyleSheet(f"QPushButton {{ background: {KOLOR_GLOWNY}; color: white; border: none; }} "                              "QPushButton:hover { background: #bf360c; }")            tak.setDefault(True)            tak.clicked.connect(lambda: self._po_ochronie(True))            self.przycisk_ochrony_tak = tak            dol.addWidget(nie)            dol.addWidget(tak)            u.addLayout(dol)            return w        def _po_antykradziezy(self):            karta = karta_rtx_do_odblokowania(self.sprzet) if "nvidia_rtx" in self.opcje else None            if karta:                             # zgoda na nVidia Unlock RTX                self.e_nvidia.setText(TEKST_NVIDIA_RTX.format(karta=nazwa_karty(karta[0])))                self.zgoda_nvidia.setChecked(False)                self.stos.setCurrentWidget(self.strona_nvidia)            else:                self.wybrane_nvidia = False                self.rozpocznij(self.wybrany_numlock)        def _po_nvidia(self, tak: bool):            self.wybrane_nvidia = tak            self.rozpocznij(self.wybrany_numlock)        # ----- Strona: nVidia Unlock RTX -----        def _zbuduj_strone_nvidia(self) -> QWidget:            w, u = strona_bazowa()            u.addWidget(etykieta("nVidia Unlock RTX – szybsze AI (na własne ryzyko)", "tytul"))            self.e_nvidia = etykieta("", "podtytul")            self.e_nvidia.setStyleSheet("font-size: 11pt; color: #2b2522;")            u.addWidget(self.e_nvidia)            u.addSpacing(6)            self.zgoda_nvidia = QCheckBox("Rozumiem ryzyko i chcę włączyć nVidia Unlock RTX "                                          "na własną odpowiedzialność")            u.addWidget(self.zgoda_nvidia)            u.addStretch(1)            dol = QHBoxLayout()            wstecz = przycisk("‹  Wstecz", "link")            wstecz.clicked.connect(lambda: self.stos.setCurrentWidget(self._strona_przed_pytaniami()))            dol.addWidget(wstecz)            dol.addStretch(1)            for tak, tekst in ((False, "Nie, bez odblokowania"), (True, "Tak, włącz (na własne ryzyko)")):                b = przycisk(tekst, "duzy")       # oba wybory jednakowe – bez sugerowania                b.setStyleSheet(f"QPushButton {{ background: {KOLOR_GLOWNY}; color: white; border: none; }} "                                "QPushButton:disabled { background: #f3c9a4; color: #fff6ee; }")                if tak:                    b.setEnabled(False)                    self.zgoda_nvidia.toggled.connect(b.setEnabled)                b.clicked.connect(lambda _=False, v=tak: self._po_nvidia(v))                dol.addWidget(b)            u.addLayout(dol)            return w        # ----- Strona: urządzenia Logitech -----        def _zbuduj_strone_logitech(self) -> QWidget:            w, u = strona_bazowa()            u.addWidget(etykieta("Czy masz któreś z tych urządzeń Logitech?", "tytul"))            u.addWidget(etykieta(                "Zaznacz, jeśli tak – zainstalujemy do nich oprogramowanie. Urządzenia podłączone "                "teraz do komputera są już zaznaczone. Jeśli nie masz żadnego, po prostu kliknij "                "„Rozpocznij”.", "podtytul"))            u.addSpacing(10)            wykryte = wykryj_logitech()            self.pola_logitech = {}            for id_, (nazwa_u, opis_u, _) in LOGITECH.items():                pole = QCheckBox(f"{nazwa_u} – {opis_u}"                                 + ("   ✔ wykryto podłączone" if id_ in wykryte else ""))                pole.setChecked(id_ in wykryte)                pole.setStyleSheet("QCheckBox { font-size: 12pt; padding: 8px 0; }")                self.pola_logitech[id_] = pole                u.addWidget(pole)            u.addSpacing(6)            u.addWidget(etykieta(                "Oprogramowanie do zaznaczonych urządzeń uruchamia się samo – podświetlenie ustawia "                "się już przy starcie komputera, jeszcze przed logowaniem.", "stopka"))            u.addStretch(1)            dol = QHBoxLayout()            wstecz = przycisk("‹  Wstecz", "link")            wstecz.clicked.connect(lambda: self.stos.setCurrentWidget(                self._strona_przed_pytaniami()))            dol.addWidget(wstecz)            dol.addStretch(1)            start = przycisk("Rozpocznij optymalizację  ›", "duzy")            start.setStyleSheet(f"background: {KOLOR_GLOWNY}; color: white; border: none;")            start.clicked.connect(self._po_logitech)            dol.addWidget(start)            u.addLayout(dol)            return w        # ----- Strona 3: postęp -----        def _zbuduj_strone_postepu(self) -> QWidget:            w, u = strona_bazowa()            u.addWidget(etykieta("Trwa optymalizacja systemu…", "tytul"))            self.e_biezacy = etykieta("Oczekiwanie na uprawnienia administratora…", "biezacy")            u.addWidget(self.e_biezacy)            self.pasek = QProgressBar()            self.pasek.setRange(0, 100)            self.pasek.setFormat("%p%")            u.addWidget(self.pasek)            self.drzewo = QTreeWidget()            self.drzewo.setColumnCount(2)            self.drzewo.setHeaderLabels(["Krok", "Stan"])            self.drzewo.setRootIsDecorated(False)            self.drzewo.setIconSize(QSize(22, 22))            self.drzewo.header().setSectionResizeMode(0, QHeaderView.ResizeMode.Stretch)            self.drzewo.header().setSectionResizeMode(1, QHeaderView.ResizeMode.ResizeToContents)            u.addWidget(self.drzewo, 3)            self.przycisk_dziennika = przycisk("Pokaż szczegóły  ▾", "link")            self.przycisk_dziennika.clicked.connect(self._przelacz_dziennik)            u.addWidget(self.przycisk_dziennika, 0, Qt.AlignmentFlag.AlignLeft)            self.dziennik = QPlainTextEdit()            self.dziennik.setObjectName("dziennik")            self.dziennik.setReadOnly(True)            self.dziennik.setMaximumBlockCount(6000)            self.dziennik.setVisible(False)            u.addWidget(self.dziennik, 2)            ostrzezenie = etykieta(                "Nie zamykaj okna Konsoli, z którego uruchomiono program, i nie korzystaj w tym "                "czasie z komputera. Nie wyłączaj go i nie odłączaj internetu – instalacja trwa "                "od kilkunastu minut do godziny.", "biezacy")            ostrzezenie.setStyleSheet(f"background: #fff3e0; border-left: 5px solid {KOLOR_JASNY}; "                                      "border-radius: 6px; padding: 8px 12px; color: #2b2522;")            u.addWidget(ostrzezenie)            u.addWidget(etykieta(f"Dziennik: {PLIK_DZIENNIKA}", "stopka"))            return w        def _przelacz_dziennik(self):            widoczny = not self.dziennik.isVisible()            self.dziennik.setVisible(widoczny)            self.przycisk_dziennika.setText("Ukryj szczegóły  ▴" if widoczny else "Pokaż szczegóły  ▾")            if self.biezacy in self.elementy:      # bieżący krok ma zostać widoczny                QTimer.singleShot(0, lambda: self.drzewo.scrollToItem(self.elementy[self.biezacy])                                  if self.biezacy in self.elementy else None)        # ----- Strona 4: koniec -----        def _zbuduj_strone_konca(self) -> QWidget:            w, u = strona_bazowa()            gora = QHBoxLayout()            self.e_ikona_konca = QLabel()            gora.addWidget(self.e_ikona_konca)            teksty = QVBoxLayout()            self.e_tytul_konca = etykieta("Gotowe!", "tytul")            self.e_licznik = etykieta("", "podtytul")            teksty.addWidget(self.e_tytul_konca)            teksty.addWidget(self.e_licznik)            gora.addLayout(teksty, 1)            u.addLayout(gora)            self.uwagi = QTextBrowser()            u.addWidget(self.uwagi, 1)            dol = QHBoxLayout()            dol.addStretch(1)            zamknij = przycisk("Zamknij")            zamknij.clicked.connect(self.close)            restart = przycisk("Uruchom ponownie teraz", "akcent")            restart.clicked.connect(self._restart)            dol.addWidget(zamknij)            dol.addWidget(restart)            u.addLayout(dol)            return w        # ----- Uruchomienie wykonawcy -----        def _wstrzymaj_usypianie(self):            """Na czas pracy: KDE nie zablokuje i nie wygasi ekranu ani nie uśpi komputera            (jak przy oglądaniu filmu). Wstrzymanie trwa, dopóki program jest otwarty –            KDE zwalnia je samo po zamknięciu okna."""            if getattr(self, "wstrzymano", False):                return            powod = "Trwa optymalizacja systemu – nie wyłączaj komputera"            uslugi = [("org.freedesktop.ScreenSaver", "/ScreenSaver", "org.freedesktop.ScreenSaver"),                      ("org.freedesktop.PowerManagement.Inhibit",                       "/org/freedesktop/PowerManagement/Inhibit",                       "org.freedesktop.PowerManagement.Inhibit")]            try:                from PyQt6.QtDBus import QDBusConnection, QDBusInterface                magistrala = QDBusConnection.sessionBus()                for usluga, sciezka, interfejs in uslugi:                    if not magistrala.isConnected():                        break                    i = QDBusInterface(usluga, sciezka, interfejs, magistrala)                    if i.isValid() and i.call("Inhibit", NAZWA_PROGRAMU, powod).arguments():                        self.wstrzymano = True            except ImportError:                pass            if not getattr(self, "wstrzymano", False) and shutil.which("systemd-inhibit"):                # zapas: blokada logind trwająca, dopóki działa ten proces                self.proces_blokady = QProcess(self)                self.proces_blokady.start("systemd-inhibit", [                    "--what=idle:sleep", "--who=" + NAZWA_PROGRAMU, "--why=" + powod,                    "--mode=block", "sleep", "infinity"])                self.wstrzymano = True        def rozpocznij(self, numlock: bool):            self._wstrzymaj_usypianie()            if not self.args.symulacja and not shutil.which("pkexec"):                QMessageBox.warning(self, NAZWA_PROGRAMU,                                    "Brak programu pkexec. Uruchom Optymalizator z terminala "                                    f"(Konsole):\n  bash {SKRYPT}")                return            self.drzewo.clear()            self.elementy.clear()            self.dziennik.clear()            self.pasek.setValue(0)            self.e_biezacy.setText("Oczekiwanie na uprawnienia administratora…")            self.stos.setCurrentWidget(self.strona_postep)            skrypt = SKRYPT if self.args.symulacja else skrypt_dla_wykonawcy()            logitech = ",".join(i for i, p in getattr(self, "pola_logitech", {}).items()                                if p.isChecked() and i in self.opcje)            argumenty = ["-u", skrypt, "--worker", "--numlock", "tak" if numlock else "nie",                         "--logitech", logitech, "--gry", "tak" if self.wybrane_gry else "nie",                         "--opcje", ",".join(self.opcje),                         "--nvidia-rtx", "tak" if self.wybrane_nvidia else "nie",                         "--antykradziez", "tak" if self.wybrana_ochrona else "nie",                         "--grafika", json.dumps(OSTATNIA_GRAFIKA),                         "--uzytkownik", getpass.getuser(), "--nazwa", self.nazwa,                         "--klucz", self.klucz, *(["--ryzyko"] if self.ryzyko else [])]            if self.args.symulacja:                program, argumenty = sys.executable, argumenty + ["--symulacja"]            else:                program, argumenty = "pkexec", ["/usr/bin/python3"] + argumenty            self.bufor = ""            self.zakonczono = False            self.otrzymano_zdarzenia = False            self.trwa = True            self.proces = QProcess(self)            self.proces.setProcessChannelMode(QProcess.ProcessChannelMode.MergedChannels)            self.proces.readyReadStandardOutput.connect(self._czytaj)            self.proces.finished.connect(self._proces_zakonczony)            self.proces.start(program, argumenty)        def _czytaj(self):            self.bufor += bytes(self.proces.readAllStandardOutput()).decode("utf-8", "replace")            while "\n" in self.bufor:                linia, self.bufor = self.bufor.split("\n", 1)                if linia.startswith(PREFIKS_ZDARZENIA):                    try:                        self._zdarzenie(json.loads(linia[len(PREFIKS_ZDARZENIA):]))                        continue                    except ValueError:                        pass                if linia.strip():                    self.dziennik.appendPlainText(linia)        def _zdarzenie(self, z: dict):            self.otrzymano_zdarzenia = True            typ = z.get("typ")            if typ == "lista_krokow":                for krok in z["kroki"]:                    el = QTreeWidgetItem([krok["tytul"], OPIS_STANU["oczekuje"]])                    el.setIcon(0, ikona_stanu("oczekuje"))                    self.drzewo.addTopLevelItem(el)                    self.elementy[krok["id"]] = el            elif typ == "krok":                el = self.elementy.get(z["id"])                if not el:                    return                stan = z["stan"]                el.setIcon(0, ikona_stanu(stan))                el.setText(1, OPIS_STANU.get(stan, stan))                el.setForeground(1, QBrush(QColor(KOLOR_STANU.get(stan, "#2b2522"))))                if z.get("info"):                    el.setToolTip(0, z["info"])                    el.setToolTip(1, z["info"])                    if stan != "ok":                        el.setText(1, f"{OPIS_STANU.get(stan, stan)}: {z['info']}"[:90])                if stan == "trwa":                    self.biezacy = z["id"]                    self.e_biezacy.setText(f"Teraz: {el.text(0)}")                    self.drzewo.scrollToItem(el)                    self.zegar.start(80)                elif self.biezacy == z["id"]:                    self.biezacy = None                    self.zegar.stop()            elif typ == "log":                self.dziennik.appendPlainText(z.get("tekst", ""))            elif typ == "postep":                self.pasek.setValue(int(z.get("procent", 0)))            elif typ == "koniec":                self.zakonczono = True                self._pokaz_koniec(z.get("podsumowanie", {}), z.get("uwagi", []))        def _obroc_wskaznik(self):            if self.biezacy and self.biezacy in self.elementy:                self.kat = (self.kat + 24) % 360                self.elementy[self.biezacy].setIcon(0, ikona_stanu("trwa", self.kat))        def _proces_zakonczony(self, kod: int, _status):            self._czytaj()            self.trwa = False            self.zegar.stop()            if self.zakonczono:                return            if not self.otrzymano_zdarzenia and kod in (126, 127):                QMessageBox.warning(self, NAZWA_PROGRAMU,                                    "Nie udzielono uprawnień administratora – nic nie zostało "                                    "zmienione.\nAby kontynuować, uruchom ponownie i wpisz hasło.")                self.stos.setCurrentWidget(self._strona_przed_pytaniami())                return            self._pokaz_koniec({"ok": 0, "ostrzezenie": 0, "blad": 1, "pominiety": 0},                               [f"Proces instalacji zakończył się nieoczekiwanie (kod {kod}). "                                f"Szczegóły: {PLIK_DZIENNIKA}"])        def _pokaz_koniec(self, p: dict, uwagi: List[str]):            bledy, ostrz = p.get("blad", 0), p.get("ostrzezenie", 0)            stan = "blad" if bledy else ("ostrzezenie" if ostrz else "ok")            self.e_ikona_konca.setPixmap(duza_ikona(stan))            self.e_tytul_konca.setText({"ok": "Gotowe! System jest zoptymalizowany.",                                        "ostrzezenie": "Gotowe – z kilkoma uwagami.",                                        "blad": "Zakończono – część kroków się nie udała."}[stan])            self.e_licznik.setText(f"Wykonano: {p.get('ok', 0)}   •   z uwagami: {ostrz}   •   "                                   f"błędy: {bledy}   •   pominięto: {p.get('pominiety', 0)}")            czesci = ['<h3 style="color:#e65100;">Ważne informacje</h3><ul>']            czesci += [f"<li style='margin-bottom:6px;'>{html.escape(u)}</li>" for u in uwagi]            czesci.append(f"</ul><p style='color:#9e8c80;'>Pełny dziennik: {PLIK_DZIENNIKA}</p>")            self.uwagi.setHtml("".join(czesci))            self.stos.setCurrentWidget(self.strona_koniec)        def _restart(self):            QProcess.startDetached("systemctl", ["reboot"])     # przycisk to już decyzja – bez dopytywania        def closeEvent(self, zdarzenie):            if self.trwa:                QMessageBox.information(self, NAZWA_PROGRAMU,                                        "Trwa instalacja – przerwanie mogłoby uszkodzić system.\n"                                        "Poczekaj, aż program skończy (możesz zminimalizować okno).")                zdarzenie.ignore()            else:                blokada = getattr(self, "proces_blokady", None)                if blokada:                    blokada.kill()                zdarzenie.accept()    # --- Aplikacja ---------------------------------------------------------------------------    app = QApplication.instance() or QApplication(sys.argv)    app.setApplicationName("optymalizator-jk")    app.setApplicationDisplayName(NAZWA_PROGRAMU)    app.setStyle("Fusion")                # jednakowy wygląd niezależnie od motywu KDE    paleta = QPalette()    for rola, kolor in ((QPalette.ColorRole.Window, "#fdf8f4"), (QPalette.ColorRole.Base, "#ffffff"),                        (QPalette.ColorRole.Text, "#2b2522"), (QPalette.ColorRole.WindowText, "#2b2522"),                        (QPalette.ColorRole.Button, "#ffffff"), (QPalette.ColorRole.ButtonText, "#2b2522"),                        (QPalette.ColorRole.Highlight, KOLOR_GLOWNY),                        (QPalette.ColorRole.HighlightedText, "#ffffff"),                        (QPalette.ColorRole.ToolTipBase, "#ffffff"),                        (QPalette.ColorRole.ToolTipText, "#2b2522")):        paleta.setColor(rola, QColor(kolor))    app.setPalette(paleta)    app.setStyleSheet(STYL)    okno = OknoGlowne(wykryj_sprzet())    return app, okno# ============================================================================# 9. START I UPRAWNIENIA# ============================================================================def pyqt6_dostepne() -> bool:    return bool(importlib.util.find_spec("PyQt6") and importlib.util.find_spec("PyQt6.QtWidgets"))def w_grupie_sudo(nazwa: str) -> bool:    """Czy konto należy do grupy sudo według /etc/group (bez ponownego logowania)."""    try:        sudo = grp.getgrnam("sudo")        return nazwa in sudo.gr_mem or pwd.getpwnam(nazwa).pw_gid == sudo.gr_gid    except KeyError:        return Falsedef regula_startowa(uzytkownik: str) -> str:    """Jednorazowa reguła polkit: konto może uruchomić część administracyjną TEGO    programu bez ponownego pytania o hasło. Dotyczy wyłącznie kopii programu należącej do    administratora (SKRYPT_STARTOWY), tylko tego konta przy komputerze i wygasa po 3 godzinach;    wykonawca usuwa ją przy starcie."""    wygasa_ms = int((time.time() + 3 * 3600) * 1000)    poczatek = "/usr/bin/python3 -u " + SKRYPT_STARTOWY + " --worker "    return f"""// Jabłoński KOMPUTERY – JEDNORAZOWA zgoda na start optymalizatora (usuwana automatycznie)// Tylko konto {uzytkownik}, tylko przy komputerze, tylko kopia programu należąca do administratora.polkit.addRule(function(action, subject) {{    if (action.id == "org.freedesktop.policykit.exec" &&            subject.user == {json.dumps(uzytkownik)} && subject.local && subject.active &&            action.lookup("program") == "/usr/bin/python3" &&            new Date().getTime() < {wygasa_ms}) {{        var polecenie = action.lookup("command_line") || "";        if (polecenie.indexOf({json.dumps(poczatek)}) == 0) {{            return polkit.Result.YES;        }}    }}}});"""def skrypt_dla_wykonawcy() -> str:    """Ścieżka programu dla części administracyjnej: kopia administratora (gdy jest identyczna    z tym plikiem – wtedy działa reguła startowa), w przeciwnym razie ten plik (pkexec zapyta    o hasło)."""    try:        if (os.stat(SKRYPT_STARTOWY).st_uid == 0 and                open(SKRYPT_STARTOWY, "rb").read() == open(SKRYPT, "rb").read()):            return SKRYPT_STARTOWY    except OSError:        pass    return SKRYPTdef brakujace_pakiety_startowe() -> List[str]:    """Pakiety potrzebne, zanim otworzy się okno: PyQt6 (okno) i pkexec – w Debianie 13    to osobny pakiet, którego świeża instalacja KDE nie zawiera."""    brakujace = []    if not pyqt6_dostepne():        brakujace.append("python3-pyqt6")    if not shutil.which("pkexec"):        brakujace += ["pkexec", "polkitd"]    return brakujacedef przygotuj_dla_uzytkownika(nazwa: str) -> int:    """(root) Przygotowanie przed otwarciem okna: PyQt6, konto w grupie sudo,    jednorazowa zgoda polkit. Wywoływane jako: optymalizator_jk.py --przygotuj KONTO."""    try:        pwd.getpwnam(nazwa)    except KeyError:        print(f"Nie ma konta {nazwa}.")        return 1    brakujace = brakujace_pakiety_startowe()    if brakujace:        print("Instaluję składniki potrzebne do okna programu: " + ", ".join(brakujace), flush=True)        kod = subprocess.run(["sh", "-c", "apt-get update && apt-get install -y " +                              " ".join(brakujace)], env=srodowisko_polecen()).returncode        if kod != 0:            print("Nie udało się zainstalować: " + ", ".join(brakujace))            return kod    if not w_grupie_sudo(nazwa):        print(f"Dodaję konto {nazwa} do grupy administratorów (sudo).", flush=True)        kod = subprocess.run(["usermod", "-aG", "sudo", nazwa]).returncode        if kod != 0:            print(f"Nie udało się dodać konta {nazwa} do grupy sudo (kod {kod}).")            return kod    katalog = os.path.dirname(SKRYPT_STARTOWY)    os.makedirs(katalog, mode=0o755, exist_ok=True)    for sciezka in (os.path.dirname(katalog), katalog):   # tylko administrator może tu zapisywać        os.chown(sciezka, 0, 0)        os.chmod(sciezka, 0o755)    shutil.copyfile(SKRYPT, SKRYPT_STARTOWY + ".nowy")    os.chown(SKRYPT_STARTOWY + ".nowy", 0, 0)    os.chmod(SKRYPT_STARTOWY + ".nowy", 0o644)    os.replace(SKRYPT_STARTOWY + ".nowy", SKRYPT_STARTOWY)    os.makedirs(os.path.dirname(REGULA_STARTOWA), exist_ok=True)    with open(REGULA_STARTOWA, "w", encoding="utf-8") as f:        f.write(regula_startowa(nazwa))    os.chmod(REGULA_STARTOWA, 0o644)    return 0def uruchom_jako_root(polecenie: List[str]) -> int:    """Uruchamia polecenie jako root, wybierając dostępną metodę:    sudo (konto w grupie sudo) → su (w terminalu, hasło konta root) → pkexec (bez terminalu)."""    if os.geteuid() == 0:        return subprocess.run(polecenie).returncode    terminal = sys.stdin.isatty()    try:        w_sudo_teraz = grp.getgrnam("sudo").gr_gid in os.getgroups()    except KeyError:        w_sudo_teraz = False    if terminal and w_sudo_teraz and shutil.which("sudo"):        return subprocess.run(["sudo", *polecenie]).returncode    if terminal:        print("Potrzebne jest hasło administratora – podaj hasło konta root:", flush=True)        return subprocess.run(["su", "root", "-c", shlex.join(polecenie)]).returncode    if shutil.which("pkexec"):        return subprocess.run(["pkexec", *polecenie]).returncode    return 1def znajdz_uzytkownika_sesji() -> Optional[Uzytkownik]:    """(root) Kto siedzi przy komputerze: SUDO_USER, PKEXEC_UID, logname, a na końcu    właściciel aktywnej sesji graficznej (loginctl)."""    kandydaci = [os.environ.get("SUDO_USER", "")]    if os.environ.get("PKEXEC_UID", "").isdigit():        try:            kandydaci.append(pwd.getpwuid(int(os.environ["PKEXEC_UID"])).pw_name)        except KeyError:            pass    try:        kandydaci.append(subprocess.run(["logname"], capture_output=True, text=True,                                        timeout=5).stdout.strip())    except (OSError, subprocess.SubprocessError):        pass    try:        sesje = subprocess.run(["loginctl", "list-sessions", "--no-legend"], capture_output=True,                               text=True, timeout=5).stdout        for linia in sesje.splitlines():            identyfikator = linia.split()[0] if linia.split() else ""            info = subprocess.run(["loginctl", "show-session", identyfikator, "-p", "Name",                                   "-p", "Type", "-p", "Active"], capture_output=True, text=True,                                  timeout=5).stdout            pola = dict(l.split("=", 1) for l in info.splitlines() if "=" in l)            if pola.get("Type") in ("wayland", "x11") and pola.get("Active") == "yes":                kandydaci.append(pola.get("Name", ""))    except (OSError, subprocess.SubprocessError, ValueError):        pass    for nazwa in kandydaci:        if nazwa and nazwa != "root":            try:                p = pwd.getpwnam(nazwa)                return Uzytkownik(p.pw_name, p.pw_uid, p.pw_gid, p.pw_dir)            except KeyError:                continue    return Nonedef srodowisko_sesji(u: Uzytkownik) -> Optional[List[str]]:    """Zmienne potrzebne, by otworzyć okno na pulpicie użytkownika (Wayland lub X11)."""    katalog = f"/run/user/{u.uid}"    if not os.path.isdir(katalog):        return None    env = [f"HOME={u.dom}", f"USER={u.nazwa}", f"LOGNAME={u.nazwa}", f"XDG_RUNTIME_DIR={katalog}",           f"DBUS_SESSION_BUS_ADDRESS=unix:path={katalog}/bus",           f"LANG={os.environ.get('LANG', 'pl_PL.UTF-8')}"]    wayland = sorted(p for p in glob.glob(f"{katalog}/wayland-*") if not p.endswith(".lock"))    if wayland:        env.append(f"WAYLAND_DISPLAY={os.path.basename(wayland[0])}")    if glob.glob("/tmp/.X11-unix/X*"):        env.append("DISPLAY=" + os.environ.get("DISPLAY", ":0"))        xauth = glob.glob(f"{katalog}/xauth_*") + glob.glob(u.sciezka(".Xauthority"))        if xauth:            env.append(f"XAUTHORITY={xauth[0]}")    return env if (wayland or any(e.startswith("DISPLAY=") for e in env)) else Nonedef start_jako_root(args) -> int:    """Program uruchomiony jako root (np. po su): przygotowujemy wszystko i otwieramy    okno na pulpicie zalogowanego użytkownika. Bez pulpitu – tryb tekstowy."""    nie_zamykaj_konsoli()    u = znajdz_uzytkownika_sesji()    env = srodowisko_sesji(u) if u else None    if not u or not env:        return uruchom_tryb_tekstowy(args)    if not sprawdz_system_w_terminalu(args):     # zanim cokolwiek zainstalujemy        return 1    kod = przygotuj_dla_uzytkownika(u.nazwa)    if kod != 0:        return uruchom_tryb_tekstowy(args)    print(f"Otwieram okno programu na pulpicie użytkownika {u.nazwa}…", flush=True)    return subprocess.run(["runuser", "-u", u.nazwa, "--", "env", *env, "/usr/bin/python3",                           SKRYPT, "--przygotowano", *dodatkowe_argumenty(args)]).returncodedef dodatkowe_argumenty(args) -> List[str]:    """Flagi przekazywane, gdy program uruchamia sam siebie ponownie."""    return (["--symulacja"] if args.symulacja else []) + (["--ryzyko"] if args.ryzyko else [])def uruchom_gui(args) -> int:    """Start okna jako zwykły użytkownik. Gdy brakuje PyQt6 albo konto nie jest    administratorem – najpierw jednorazowe przygotowanie jako root."""    uzytkownik = getpass.getuser()    pulpit = bool(os.environ.get("WAYLAND_DISPLAY") or os.environ.get("DISPLAY"))    # Sprawdzenie systemu ZANIM cokolwiek zainstalujemy. Gdy jest już PyQt6, okno samo    # pokaże odpowiednią stronę; w przeciwnym razie informujemy w terminalu.    if not args.symulacja and (not jest_kde() or (not jest_debian13() and not args.ryzyko)):        if sys.stdin.isatty() or not (pyqt6_dostepne() and pulpit):            if not sprawdz_system_w_terminalu(args):     # brak KDE → koniec; inny system → TAK                return 1        else:            # bez terminala, ale z PyQt6: okno pokaże stronę blokady albo ostrzeżenia            # (bez wcześniejszego instalowania czegokolwiek)            app, okno = utworz_okno_gui(args)            okno.show()            return app.exec()    if pulpit:        nie_zamykaj_konsoli()    if not pulpit:        print("Brak pulpitu graficznego – uruchamiam tryb tekstowy.")        return uruchom_jako_root(["/usr/bin/python3", SKRYPT, "--konsola",                                  "--uzytkownik", uzytkownik, *dodatkowe_argumenty(args)])    potrzebne = (not pyqt6_dostepne() or                 (not args.symulacja and (not w_grupie_sudo(uzytkownik) or not shutil.which("pkexec"))))    if potrzebne and not args.przygotowano:        print("Przygotowanie: instalacja brakujących składników i uprawnienia administratora.",              flush=True)        if uruchom_jako_root(["/usr/bin/python3", SKRYPT, "--przygotuj", uzytkownik]) != 0:            print("Przygotowanie nie powiodło się. Spróbuj tak:\n"                  f"  su -c 'python3 {SKRYPT} --konsola'")            return 1        os.execv("/usr/bin/python3", ["/usr/bin/python3", SKRYPT, "--przygotowano",                                      *dodatkowe_argumenty(args)])    if not pyqt6_dostepne():        print("Brak biblioteki PyQt6 – uruchom tryb tekstowy: "              f"su -c 'python3 {SKRYPT} --konsola'")        return 1    if not shutil.which("pkexec") and not args.symulacja and jest_kde():        print("Brak programu pkexec (polkit) – uruchom tryb tekstowy: "              f"su -c 'python3 {SKRYPT} --konsola'")        return 1    app, okno = utworz_okno_gui(args)    okno.show()    napisz_bezpiecznie("Okno Optymalizatora jest otwarte – NIE zamykaj tej Konsoli do końca pracy.")    kod = app.exec()    napisz_bezpiecznie("Optymalizator zakończył pracę – teraz możesz zamknąć to okno Konsoli.")    return kod# ============================================================================# 10. TRYB SESJI – ustawienia konta użytkownika (uruchamiany przy logowaniu)# ============================================================================# Ustawienia, które Plasma trzyma per konto i które najlepiej zmieniać przy# działającym pulpicie (D-Bus): motyw, tapeta, pasek zadań, ulubione, ikony na# Pulpicie, kosz, nazwa w KDE Connect. Wykonywane raz na wersję programu.AGENT_ULUBIONYCH = "org.kde.plasma.favorites.applications"INTERFEJSY_LINKOWANIA = ["org.kde.ActivityManager.ResourcesLinking",                         "org.kde.ActivityManager.Resources.Linking"]def busctl_uzytkownika(*argumenty: str, sprawdz: bool = True) -> Tuple[int, str]:    return uruchom(["busctl", "--user", *argumenty], sprawdz=sprawdz, cicho=True)def czekaj_na_plasme(sekundy: int = 90) -> bool:    if SYMULACJA:        return True    for _ in range(sekundy // 2):        kod, _ = busctl_uzytkownika("status", "org.kde.plasmashell", sprawdz=False)        if kod == 0:            return True        time.sleep(2)    return Falsedef plik_desktop(nazwa: str) -> Optional[str]:    """„brave-browser.desktop” → ten sam plik, jeśli istnieje; „wordcraft” → wyszukany."""    if nazwa.endswith(".desktop"):        katalogi = KATALOGI_DESKTOP + [os.path.expanduser("~/.local/share/applications")]        istnieje = any(os.path.exists(os.path.join(d, nazwa)) for d in katalogi)        return nazwa if istnieje or SYMULACJA else None    return znajdz_plik_desktop(nazwa) or (f"{nazwa}.desktop" if SYMULACJA else None)def sesja_motyw() -> str:    offscreen = {"QT_QPA_PLATFORM": "offscreen"}     # narzędzia KDE nie otwierają okien    uruchom(["plasma-apply-lookandfeel", "--apply", MOTYW_KDE], sprawdz=False, srodowisko=offscreen)    uruchom(["plasma-apply-colorscheme", SCHEMAT_KOLOROW], sprawdz=False, srodowisko=offscreen)    uruchom(["plasma-apply-colorscheme", "--accent-color", KOLOR_AKCENTU], sprawdz=False,            srodowisko=offscreen)    ini = IniPlik(os.path.expanduser("~/.config/kdeglobals"))   # dla pewności także w pliku    ini.ustaw("General", "AccentColor", KOLOR_AKCENTU_KDE)    ini.ustaw("General", "accentColorFromWallpaper", "false")    ini.zapisz()    return "jasny Breeze, akcent pomarańczowy"def sesja_tapeta() -> str:    if not os.path.exists(TAPETA_PLIK) and not SYMULACJA:        return "brak pliku tapety – pominięto"    obrazy = Uzytkownik.biezacy().katalog_xdg("XDG_PICTURES_DIR", "Obrazy")    cel = os.path.join(obrazy, TAPETA_NAZWA_U_UZYTKOWNIKA)    kopiuj_plik(TAPETA_PLIK, cel)    uruchom(["plasma-apply-wallpaperimage", cel])    return celdef sesja_pasek_zadan() -> str:    przypiete = [f"applications:{d}" for d in map(plik_desktop, PASEK_ZADAN) if d]    skrypt = """        var przypiete = %s;        panels().forEach(function (panel) {            panel.widgets().forEach(function (w) {                if (w.type == "org.kde.plasma.icontasks" || w.type == "org.kde.plasma.taskmanager") {                    w.currentConfigGroup = ["General"];                    w.writeConfig("launchers", przypiete);                    w.reloadConfig();                }            });        });    """ % json.dumps(przypiete)    busctl_uzytkownika("call", "org.kde.plasmashell", "/PlasmaShell", "org.kde.PlasmaShell",                       "evaluateScript", "s", skrypt)    return ", ".join(przypiete)def linkowanie(metoda: str, zasob: str, aktywnosc: str) -> None:    """Wywołanie usługi aktywności KDE – w niej Plasma 6 trzyma ulubione menu."""    for interfejs in INTERFEJSY_LINKOWANIA:        kod, _ = busctl_uzytkownika("call", "org.kde.ActivityManager",                                    "/ActivityManager/Resources/Linking", interfejs, metoda,                                    "sss", AGENT_ULUBIONYCH, zasob, aktywnosc, sprawdz=False)        if kod == 0:            return    raise BladPolecenia(f"{metoda} {zasob}: usługa aktywności KDE nie odpowiada")def sesja_ulubione() -> str:    import sqlite3    nowe = [f"applications:{d}" for d in map(plik_desktop, ULUBIONE) if d]    baza = os.path.expanduser("~/.local/share/kactivitymanagerd/resources/database")    obecne = []    if os.path.exists(baza):        with sqlite3.connect(f"file:{baza}?mode=ro", uri=True) as polaczenie:            obecne = polaczenie.execute(                "SELECT usedActivity, targettedResource FROM ResourceLink WHERE initiatingAgent=?",                (AGENT_ULUBIONYCH,)).fetchall()    for aktywnosc, zasob in obecne:        if zasob not in nowe:            linkowanie("UnlinkResourceFromActivity", zasob, aktywnosc)    for zasob in nowe:        linkowanie("LinkResourceToActivity", zasob, ":global")    # kolejność ulubionych w menu    ini = IniPlik(os.path.expanduser("~/.config/kactivitymanagerd-statsrc"))    grupy = [g for g in ini.grupy() if g.startswith("Favorites-")]    for g in grupy:        ini.ustaw(g, "ordering", ",".join(nowe))    if grupy:        ini.zapisz()    return ", ".join(nowe)def sesja_ikony_pulpitu() -> str:    pulpit = Uzytkownik.biezacy().katalog_xdg("XDG_DESKTOP_DIR", "Pulpit")    for nazwa, tresc, tryb in pliki_pulpitu():        zapisz_plik(os.path.join(pulpit, nazwa), tresc, tryb)    return pulpitdef sesja_kosz() -> str:    dane = os.environ.get("XDG_DATA_HOME") or os.path.expanduser("~/.local/share")    ini = IniPlik(os.path.expanduser("~/.config/ktrashrc"))    grupa = os.path.join(dane, "Trash")    for klucz, wartosc in (("UseTimeLimit", "true"), ("Days", str(KOSZ_DNI)),                           ("UseSizeLimit", "true"), ("Percent", str(KOSZ_PROCENT)),                           ("LimitReachedAction", str(KOSZ_AKCJA))):        ini.ustaw(grupa, klucz, wartosc)    ini.zapisz()    return f"{KOSZ_DNI} dni, limit {KOSZ_PROCENT}% – najpierw najstarsze"def sesja_kdeconnect() -> str:    nazwa = obecna_nazwa_komputera()    ini = IniPlik(os.path.expanduser("~/.config/kdeconnect/config"))    ini.ustaw("General", "name", nazwa)    ini.zapisz()    return nazwadef uruchom_tryb_sesji(wymus: bool) -> int:    global RAPORT    RAPORT = Raport("sesja")    znacznik = os.path.expanduser("~/.config/jablonski-komputery/sesja-wersja")    try:                         # profil poczty mógł powstać dopiero po instalacji        wynik = sesja_poczta()        if wynik != "bez zmian":            log(f"[poczta] {wynik}")    except Exception as e:       # noqa: BLE001        log(f"[poczta] BŁĄD: {e}")    znacznik_tapety = os.path.expanduser("~/.config/jablonski-komputery/tapeta-wersja")    try:                         # tapeta zmieniona (np. w panelu) – ustawiamy ją przy logowaniu        wersja_tapety = str(int(os.path.getmtime(TAPETA_PLIK)))        if not wymus and czytaj(znacznik).strip() == WERSJA and czytaj(znacznik_tapety).strip() != wersja_tapety:            if czekaj_na_plasme():                log(f"[tapeta] {sesja_tapeta()}")                zapisz_plik(znacznik_tapety, wersja_tapety + "\n")    except Exception as e:       # noqa: BLE001        log(f"[tapeta] BŁĄD: {e}")    if not wymus and czytaj(znacznik).strip() == WERSJA:        return 0    log(f"===== {time.strftime('%Y-%m-%d %H:%M:%S')} – ustawienia konta {getpass.getuser()} =====")    if not czekaj_na_plasme():        log("Plasma nie odpowiada – spróbuję przy następnym logowaniu.")        return 1    bledy = 0    for nazwa, funkcja in (("motyw", sesja_motyw), ("tapeta", sesja_tapeta),                           ("pasek zadań", sesja_pasek_zadan), ("ulubione", sesja_ulubione),                           ("ikony na Pulpicie", sesja_ikony_pulpitu), ("kosz", sesja_kosz),                           ("KDE Connect", sesja_kdeconnect)):        try:            log(f"[{nazwa}] {funkcja()}")        except Exception as e:     # noqa: BLE001 – jedno niepowodzenie nie blokuje reszty            bledy += 1            log(f"[{nazwa}] BŁĄD: {e}")    zapisz_plik(znacznik, WERSJA + "\n")    if os.path.exists(TAPETA_PLIK):        zapisz_plik(znacznik_tapety, str(int(os.path.getmtime(TAPETA_PLIK))) + "\n")    return 0 if bledy == 0 else 2# ============================================================================# 10b. KOMUNIKATY I ZGŁASZANIE URUCHOMIEŃ# ============================================================================# Usługa systemowa (--zglos-start) po każdym starcie zgłasza serwerowi uruchomienie.# Autostart w sesji KDE (--komunikaty) pobiera komunikaty dla komputera i pokazuje je# na środku ekranu: jednorazowe – po kliknięciu OK serwer dostaje potwierdzenie odczytu;# stałe – przy każdym logowaniu, dopóki są w panelu.def wczytaj_licencje() -> Optional[Dict[str, str]]:    try:        dane = json.loads(czytaj(PLIK_LICENCJI) or "{}")    except ValueError:        return None    return dane if normalizuj_klucz(dane.get("klucz", "")) else Nonedef zapytanie_z_ponowieniem(parametry: Dict[str, str], proby: int = 18,                            przerwa: float = 10) -> Optional[str]:    """Zaraz po starcie sieć bywa jeszcze niegotowa – próbujemy przez ok. 3 minuty."""    for proba in range(proby):        try:            return zapytaj_serwer_licencji(parametry)        except (urllib.error.URLError, OSError):            if proba < proby - 1:                time.sleep(przerwa)    return Nonedef parametry_komputera() -> Optional[Dict[str, str]]:    licencja = wczytaj_licencje()    if not licencja:        return None    sprzet, _ = identyfikator_sprzetu()    return {"klucz": licencja["klucz"], "sprzet": sprzet, "host": obecna_nazwa_komputera()}WZORZEC_ID_RUSTDESK = re.compile(r"^[A-Za-z0-9_-]{6,32}$")def identyfikator_rustdesk(proby: int = 6) -> Optional[str]:    """(root) Numer ID RustDesk tego komputera – do pomocy zdalnej. Najpierw „rustdesk    --get-id” (usługa RustDesk działa jako root), potem plik konfiguracji (wersja .deb    i Flatpak). Tuż po starcie systemu RustDesk bywa jeszcze nieuruchomiony – czekamy chwilę."""    pliki = ["/root/.config/rustdesk/RustDesk.toml"]    for u in lista_uzytkownikow():        pliki += [u.sciezka(".config", "rustdesk", "RustDesk.toml"),                  u.sciezka(".var", "app", "com.rustdesk.RustDesk", "config", "rustdesk",                            "RustDesk.toml")]    for proba in range(proby):        if shutil.which("rustdesk"):            for linia in reversed(_wynik_polecenia(["rustdesk", "--get-id"]).split()):                if WZORZEC_ID_RUSTDESK.match(linia.strip()) and any(z.isdigit() for z in linia):                    return linia.strip()        for plik in pliki:            m = re.search(r"^id\s*=\s*['\"]([A-Za-z0-9_-]{6,32})['\"]", czytaj(plik), re.M)            if m:                return m.group(1)        if proba < proby - 1:            time.sleep(10)    return Nonedef zglos_uruchomienie() -> int:    """(usługa systemowa) ?start=1 – serwer zapisuje czas uruchomienia komputera    i aktualny numer ID RustDesk (pomoc zdalna; połączenie i tak wymaga zgody klienta)."""    parametry = parametry_komputera()    if not parametry:        print("Brak licencji – nie zgłaszam uruchomienia.")        return 0    try:        zapisz_odcisk_sprzetu()                       # np. po wymianie dysku    except OSError:        pass    rustdesk = identyfikator_rustdesk()    if rustdesk:        parametry["rustdesk"] = rustdesk    odpowiedz = zapytanie_z_ponowieniem({"start": "1", **parametry})    print(f"ID RustDesk: {rustdesk or 'nie odczytano'}")    print(f"Zgłoszenie uruchomienia: {odpowiedz or 'brak połączenia z serwerem'}")    return 0# --- Stan komputera: pakiet i tryb „zgubiony / skradziony” ------------------------------------# Usługa systemowa (--stan) przy starcie – jeszcze przed ekranem logowania – i co 10 minut pyta# serwer o stan. Gdy komputer zablokowano (panel albo zgłoszenie klienta na stronie): wszystkie konta# zablokowane, zamiast ekranu logowania tylko komunikat i „Wyłącz komputer”. Stan zostaje# zapamiętany, więc działa także bez internetu – do odblokowania, które przywraca stan sprzed blokady.def antykradziez_wlaczona() -> bool:    return os.path.exists(PLIK_ANTYKRADZIEZY)def krok_antykradziez(k: Kontekst) -> str:    """Zgoda klienta (pytanie w programie). Bez zgody zdalna blokada na tym komputerze nie działa,    nawet jeśli ktoś ustawi ją w panelu."""    if k.antykradziez:        if not antykradziez_wlaczona():            zapisz_plik(PLIK_ANTYKRADZIEZY, json.dumps({"zgoda": time.strftime("%Y-%m-%d %H:%M:%S")}) + "\n",                        0o644)        opis = "włączona – za Twoją zgodą"    else:        usun_plik(PLIK_ANTYKRADZIEZY)        wylacz_tryb_zgubiony()                       # gdyby była aktywna blokada – zdejmujemy        opis = "wyłączona – nie wyraziłeś(-aś) zgody"    systemctl("start", "--no-block", USLUGA_STANU)   # serwer od razu wie, czy ochrona działa    return opisdef siec_gotowa(czekaj: float = 8) -> bool:    """Czy jest internet (NetworkManager). Czekamy tylko, gdy połączenie właśnie się nawiązuje –    bez sieci (brak kabla, Wi-Fi poza zasięgiem) rezygnujemy po 2 s, żeby nie opóźniać startu."""    if not shutil.which("nmcli"):        return True                                      # bez nmcli – po prostu próbujemy    start = time.monotonic()    while True:        stan = _wynik_polecenia(["nmcli", "-t", "-f", "STATE", "general"]).strip()        if stan.startswith("connected") and "local" not in stan:            return True        uplynelo = time.monotonic() - start        if uplynelo > czekaj or (uplynelo > 2 and not stan.startswith("connecting")):            return False        time.sleep(0.5)def sprawdz_stan() -> int:    """(usługa systemowa, root) ?stan=1 – opcje pakietu i tryb „zgubiony / skradziony”."""    parametry = parametry_komputera()    if not parametry:        print("Brak licencji – nie sprawdzam stanu.")        return 0    # Bez internetu albo gdy serwer nie działa / odpowiada czymś niezrozumiałym: NIC nie zmieniamy    # i nic nie wyświetlamy – komputer działa jak dotąd, kolejna próba za 10 minut. Przy starcie    # (przed ekranem logowania) najwyżej jedna krótka próba, żeby nie opóźniać uruchomienia.    przy_starcie = not _ekran_logowania_aktywny()    # Minimalizacja danych: co 10 minut pytamy tylko komputery z włączoną J.K. Anty-Kradzieżą    # (blokada musi działać szybko). Pozostałe – przy starcie i najwyżej co 6 godzin (aktualizacje).    if not przy_starcie and not antykradziez_wlaczona() and os.path.exists(PLIK_STANU) \            and time.time() - os.path.getmtime(PLIK_STANU) < CO_ILE_STAN_BEZ_OCHRONY:        return 0    odpowiedz = None    if siec_gotowa():        for proba in range(1 if przy_starcie else 2):            try:                odpowiedz = zapytaj_serwer_licencji({"stan": "1", "antykradziez": "1" if antykradziez_wlaczona()                                                     else "0", **parametry}, czas=4 if przy_starcie else 10)                break            except (urllib.error.URLError, OSError, ValueError):                if not przy_starcie:                    time.sleep(3)    if not odpowiedz or not re.match(r"STAN: (OK|ZGUBIONY)\b", odpowiedz):        print(f"Brak poprawnej odpowiedzi serwera ({(odpowiedz or 'brak połączenia')[:60]}) – bez zmian.")        return 0    pola = {}    for linia in odpowiedz.splitlines():        nazwa, _, wartosc = linia.partition(":")        pola[nazwa.strip().upper()] = wartosc.strip()    opcje = sorted(o for o in pola.get("OPCJE", "").split(",") if o in OPCJE_PROGRAMU)    zapisz_plik(PLIK_STANU, json.dumps({"czas": time.strftime("%Y-%m-%d %H:%M:%S"), "opcje": opcje,                                        "pakiet": pola.get("PAKIET", ""),                                        "grafika": grafika_z_odpowiedzi(odpowiedz)},                                       ensure_ascii=False) + "\n", 0o644)    if pola.get("STAN") == "ZGUBIONY" and antykradziez_wlaczona():     # blokada tylko za zgodą klienta        try:            tresc = base64.b64decode(pola.get("KOMUNIKAT", "")).decode("utf-8")        except ValueError:            tresc = ""        wlacz_tryb_zgubiony(tresc)        print("Stan: ZGUBIONY / SKRADZIONY")    else:        wylacz_tryb_zgubiony()        print(f"Stan: OK, pakiet {pola.get('PAKIET', '?')}")    return 0def _ekran_logowania_aktywny() -> bool:    _, stan = uruchom(["systemctl", "is-active", "display-manager"], sprawdz=False, cicho=True,                      tylko_odczyt=True)    return stan.strip() == "active"def _sesje_graficzne() -> List[str]:    sesje = []    for linia in _wynik_polecenia(["loginctl", "list-sessions", "--no-legend"]).splitlines():        if not linia.split():            continue        nr = linia.split()[0]        wlasciwosci = _wynik_polecenia(["loginctl", "show-session", nr, "-p", "Type", "-p", "Class"])        if "Class=user" in wlasciwosci and re.search(r"Type=(x11|wayland)", wlasciwosci):            sesje.append(nr)    return sesjedef wlacz_tryb_zgubiony(tresc: str) -> None:    """Blokada: wszystkie konta (także root) zablokowane – hasło z „!” i konto wygasłe (bez logowania    z ekranu, konsoli tekstowej, su ani SSH), autologowanie wyłączone, zamiast ekranu logowania tylko    komunikat i przycisk „Wyłącz komputer”. Oryginalne wpisy /etc/shadow zapisujemy, by po odblokowaniu    przywrócić dokładnie stan sprzed blokady."""    try:        poprzedni = json.loads(czytaj(PLIK_ZGUBIONY) or "{}")    except ValueError:        poprzedni = {}    tresc = tresc.strip() or "Ten komputer został zgłoszony jako zgubiony lub skradziony."    pierwszy_raz = "konta" not in poprzedni    stan = {"tresc": tresc, "od": poprzedni.get("od") or time.strftime("%Y-%m-%d %H:%M:%S"),            "konta": poprzedni.get("konta", {}), "ssh": poprzedni.get("ssh", False)}    if pierwszy_raz:        cienie = wpisy_shadow()        for nazwa in ["root"] + [u.nazwa for u in lista_uzytkownikow()]:            if nazwa in cienie and nazwa not in stan["konta"]:                stan["konta"][nazwa] = cienie[nazwa]           # {"haslo": …, "wygasa": …}        # najpierw zapis (0600) – nawet przerwana blokada da się cofnąć        zapisz_plik(PLIK_ZGUBIONY, json.dumps(stan, ensure_ascii=False) + "\n", 0o600)        for nazwa in stan["konta"]:            uruchom(["usermod", "-L", nazwa], sprawdz=False)            if nazwa != "root":                                  # root: tylko hasło (cron, usługi)                uruchom(["chage", "-E", "1", nazwa], sprawdz=False)        if os.path.isdir(os.path.dirname(SSH_ZGUBIONY)):            zapisz_plik(SSH_ZGUBIONY, "# Jabłoński KOMPUTERY – komputer zablokowany\nDenyUsers *\n")            stan["ssh"] = True            uruchom(["systemctl", "try-reload-or-restart", "ssh.service"], sprawdz=False, cicho=True)    zmiana = pierwszy_raz or poprzedni.get("tresc") != tresc    zapisz_motyw_zgubiony(tresc)    zapisz_plik(SDDM_ZGUBIONY, "# Jabłoński KOMPUTERY – komputer zablokowany (zgubiony/skradziony)\n"                               "[Theme]\nCurrent=jablonski-zgubiony\n"                               "[Autologin]\nUser=\nSession=\nRelogin=false\n")    zapisz_plik(PLIK_ZGUBIONY, json.dumps(stan, ensure_ascii=False) + "\n", 0o600)    if zmiana and _ekran_logowania_aktywny():             # komputer już działa – zamykamy sesje        uruchom(["systemctl", "restart", "display-manager"], sprawdz=False)def wylacz_tryb_zgubiony() -> None:    """Odblokowanie: dokładnie poprzednie hasła i daty ważności kont, zwykły ekran logowania."""    if not os.path.exists(PLIK_ZGUBIONY) and not os.path.exists(SDDM_ZGUBIONY):        return    try:        stan = json.loads(czytaj(PLIK_ZGUBIONY) or "{}")    except ValueError:        stan = {}    for nazwa, wpis in stan.get("konta", {}).items():        uruchom(["usermod", "-p", wpis.get("haslo", ""), nazwa], sprawdz=False)        if "zmiana" in wpis:                                   # data zmiany hasła – jak przed blokadą            uruchom(["chage", "-d", wpis["zmiana"] or "-1", nazwa], sprawdz=False)        if nazwa != "root":            uruchom(["chage", "-E", wpis.get("wygasa") or "-1", nazwa], sprawdz=False)    if stan.get("ssh") or os.path.exists(SSH_ZGUBIONY):        usun_plik(SSH_ZGUBIONY)        uruchom(["systemctl", "try-reload-or-restart", "ssh.service"], sprawdz=False, cicho=True)    usun_plik(SDDM_ZGUBIONY)    usun_plik(MOTYW_ZGUBIONY)    usun_plik(PLIK_ZGUBIONY)    if _ekran_logowania_aktywny() and not _sesje_graficzne():   # zwykły ekran logowania od razu        uruchom(["systemctl", "restart", "display-manager"], sprawdz=False)def wpisy_shadow() -> Dict[str, Dict[str, str]]:    """{konto: {"haslo": pole 2, "zmiana": pole 3, "wygasa": pole 8}} z /etc/shadow (tylko root)."""    wynik = {}    for linia in czytaj("/etc/shadow").splitlines():        pola = linia.split(":")        if len(pola) >= 8:            wynik[pola[0]] = {"haslo": pola[1], "zmiana": pola[2], "wygasa": pola[7]}    return wynikdef zapisz_motyw_zgubiony(tresc: str) -> None:    """Motyw SDDM zablokowanego komputera: komunikat z panelu i przycisk „Wyłącz komputer” – bez logowania."""    zapisz_plik(f"{MOTYW_ZGUBIONY}/metadata.desktop", MOTYW_ZGUBIONY_METADANE)    zapisz_plik(f"{MOTYW_ZGUBIONY}/theme.conf", "[General]\n")    zapisz_plik(f"{MOTYW_ZGUBIONY}/Main.qml",                MOTYW_ZGUBIONY_QML.replace("@@KOMUNIKAT@@", json.dumps(tresc, ensure_ascii=False)))MOTYW_ZGUBIONY_METADANE = """\[SddmGreeterTheme]Name=Jabłoński KOMPUTERY – komputer zablokowanyDescription=Komunikat dla znalazcy – bez możliwości logowaniaAuthor=Jabłoński KOMPUTERYWebsite=https://www.k.j.plType=sddm-themeVersion=2.0MainScript=Main.qmlConfigFile=theme.confQtVersion=6"""MOTYW_ZGUBIONY_QML = r"""// Jabłoński KOMPUTERY – ekran komputera zablokowanego (zgubiony / skradziony): bez logowaniaimport QtQuick 2.15Rectangle {    id: ekran    width: 1920    height: 1080    gradient: Gradient {        GradientStop { position: 0.0; color: "#b71c1c" }        GradientStop { position: 1.0; color: "#4a1410" }    }    property string komunikat: @@KOMUNIKAT@@    property real s: Math.max(0.55, Math.min(width / 1920, height / 1080))    Column {        anchors.centerIn: parent        width: parent.width * 0.8        spacing: 26 * ekran.s        Text {            width: parent.width            horizontalAlignment: Text.AlignHCenter            text: "KOMPUTER ZABLOKOWANY"            color: "#ffcc80"            font.pixelSize: 30 * ekran.s            font.bold: true            font.letterSpacing: 6 * ekran.s        }        Text {            width: parent.width            horizontalAlignment: Text.AlignHCenter            wrapMode: Text.WordWrap            text: ekran.komunikat            color: "white"            font.pixelSize: 42 * ekran.s            font.bold: true            lineHeight: 1.15        }        Item { width: 1; height: 30 * ekran.s }        Rectangle {            anchors.horizontalCenter: parent.horizontalCenter            width: napis.width + 80 * ekran.s            height: 64 * ekran.s            radius: 32 * ekran.s            color: mysz.containsMouse ? "#ffffff" : "#fff3e0"            Text {                id: napis                anchors.centerIn: parent                text: "Wyłącz komputer"                color: "#b71c1c"                font.pixelSize: 24 * ekran.s                font.bold: true            }            MouseArea { id: mysz; anchors.fill: parent; hoverEnabled: true; onClicked: sddm.powerOff() }        }    }    Text {        anchors.horizontalCenter: parent.horizontalCenter        anchors.bottom: parent.bottom        anchors.bottomMargin: 30 * ekran.s        text: "Jabłoński KOMPUTERY  •  www.k.j.pl"        color: "#ffccbc"        opacity: 0.8        font.pixelSize: 17 * ekran.s    }}"""def _plik_odczytanych() -> str:    return os.path.expanduser("~/.local/state/jablonski-komputery/odczytane.json")def _odczytane_lokalnie() -> Dict[str, bool]:    """{id: czy_serwer_potwierdził} – zapamiętane odczyty komunikatów jednorazowych    (gdy potwierdzenie nie dotarło do serwera, wysyłamy je ponownie przy następnym logowaniu)."""    try:        return json.loads(czytaj(_plik_odczytanych()) or "{}")    except ValueError:        return {}def _zapisz_odczytane(dane: Dict[str, bool]) -> None:    os.makedirs(os.path.dirname(_plik_odczytanych()), exist_ok=True)    with open(_plik_odczytanych(), "w", encoding="utf-8") as f:        json.dump(dane, f)def potwierdz_odczyt(parametry: Dict[str, str], identyfikator: str) -> bool:    try:        odp = zapytaj_serwer_licencji({"odczytano": identyfikator, **parametry})   # bez nazwy konta        return odp.strip() == "OK"    except (urllib.error.URLError, OSError):        return Falsedef pobierz_komunikaty(parametry: Dict[str, str]) -> List[Dict[str, str]]:    odpowiedz = zapytanie_z_ponowieniem({"komunikaty": "1", **parametry})        # bez nazwy konta    try:        dane = json.loads(odpowiedz or "{}")    except ValueError:        return []    lista = dane.get("komunikaty", []) if isinstance(dane, dict) else []    if not isinstance(lista, list):        return []    return [m for m in lista if isinstance(m, dict) and m.get("id")]def uruchom_komunikaty() -> int:    """(autostart w sesji) Pobiera i wyświetla komunikaty dla tego komputera."""    parametry = parametry_komputera()    if not parametry:        return 0    odczytane = _odczytane_lokalnie()    for identyfikator, potwierdzono in list(odczytane.items()):   # zaległe potwierdzenia        if not potwierdzono:            odczytane[identyfikator] = potwierdz_odczyt(parametry, identyfikator)    komunikaty = [m for m in pobierz_komunikaty(parametry)                  if not (m.get("typ") == "jednorazowy" and m["id"] in odczytane)]    if komunikaty and pyqt6_dostepne():        for m in pokaz_komunikaty(komunikaty):           # id odczytanych jednorazowych            odczytane[m] = potwierdz_odczyt(parametry, m)    _zapisz_odczytane(odczytane)    # aktualizacja z panelu (pakiet, grafika) – bez pytania, od razu po zalogowaniu    if zmienil_sie_pakiet() and pyqt6_dostepne() and serwer_dostepny():        uruchom_aktualizacje(TEKST_AKTUALIZACJI)    return 0def uruchom_naprawe() -> int:    """Menu „Aktualizuj ustawienia”: przywraca konfigurację Optymalizatora – tak jak przy instalacji,    z tymi samymi wyborami i aktualnym pakietem – od razu, bez pytań."""    if not pyqt6_dostepne():        return 1    if not serwer_dostepny():        from PyQt6.QtWidgets import QApplication, QMessageBox        _ = QApplication.instance() or QApplication(sys.argv)        okno = QMessageBox(QMessageBox.Icon.Information, "Jabłoński KOMPUTERY",                           "Brak połączenia z serwerem Jabłoński KOMPUTERY. Sprawdź internet "                           "i spróbuj ponownie za chwilę.")        okno.addButton("OK", QMessageBox.ButtonRole.AcceptRole)        okno.exec()        return 1    uruchom_aktualizacje(TEKST_NAPRAWY)    return 0def serwer_dostepny() -> bool:    """Czy serwer licencji odpowiada – bez niego aktualizacja i tak by się nie udała, więc nie pytamy."""    try:        odpowiedz = zapytaj_serwer_licencji({"ping": "1"}, czas=6)        return odpowiedz == "PONG" or "serwer licencji" in odpowiedz     # starszy serwer – bez „PONG”    except (urllib.error.URLError, OSError, ValueError):        return Falsedef zmienil_sie_pakiet() -> bool:    """Czy opcje pakietu w panelu (stan.json z usługi przy starcie) różnią się od tych,    z którymi Optymalizator skonfigurował komputer (licencja.json)."""    try:        licencja = json.loads(czytaj(PLIK_LICENCJI) or "{}")        stan = json.loads(czytaj(PLIK_STANU) or "{}")    except ValueError:        return False    zainstalowane, serwer = licencja.get("opcje"), stan.get("opcje")    if zainstalowane is None or serwer is None:          # starsza instalacja / brak odpowiedzi serwera        return False    if set(zainstalowane) != set(serwer):        return True    # grafika zmieniona w panelu (porównujemy tylko, gdy instalacja ją zapamiętała)    return "grafika" in licencja and "grafika" in stan and licencja["grafika"] != stan["grafika"]TEKST_PROSBY = ("Ten proces może chwilę potrwać aby zapewnić Ci jeszcze lepsze doznania z Twojego urządzenia. "                "Nie używaj teraz komputera proszę i poczekaj do zakończenia tego procesu.")TEKST_AKTUALIZACJI = "Wykryto aktualizacje ustawień systemu specjalnie dla Ciebie.\n" + TEKST_PROSBYTEKST_NAPRAWY = "Przywracamy ustawienia systemu – tak jak przy instalacji. Twoje pliki zostają nietknięte.\n" \                + TEKST_PROSBYdef uruchom_aktualizacje(powod: str = "") -> None:    """Rekonfiguracja bez pytań: usługa systemowa (bez hasła – reguła polkit) i okno postępu.    Gdy usługi nie ma (starsza instalacja) – najnowszy Optymalizator w Konsoli, jak przy instalacji."""    zadanie = f"u{os.getuid()}x{secrets.token_hex(4)}"    kod, _ = uruchom(["systemctl", "start", "--no-block", USLUGA_AKTUALIZACJI.replace("@", "@" + zadanie)],                     sprawdz=False, cicho=True)    if kod == 0:        pokaz_postep_aktualizacji(os.path.join(KATALOG_STANU, f"aktualizacja-{zadanie}.log"), powod)        return    for polecenie in (["konsole", "-e", "sh", "-c", POLECENIE_STARTU],                      ["x-terminal-emulator", "-e", "sh", "-c", POLECENIE_STARTU]):        if shutil.which(polecenie[0]):            subprocess.Popen(polecenie, start_new_session=True, stdin=subprocess.DEVNULL,                             stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)            returndef pokaz_postep_aktualizacji(plik_logu: str, powod: str = "") -> None:    """Okno postępu – czyta zdarzenia wykonawcy z pliku zapisywanego przez usługę."""    from PyQt6.QtCore import QTimer, Qt    from PyQt6.QtGui import QGuiApplication    from PyQt6.QtWidgets import (QApplication, QDialog, QHBoxLayout, QLabel, QProgressBar,                                 QPushButton, QVBoxLayout)    app = QApplication.instance() or QApplication(sys.argv)    app.setApplicationName("jk-aktualizacja")    okno = QDialog()    okno.setWindowTitle("Jabłoński KOMPUTERY – aktualizacja ustawień")    okno.setStyleSheet(        "QDialog { background: #fdf8f4; } QLabel { color: #2b2522; } "        "QLabel#pasek { background: qlineargradient(x1:0, y1:0, x2:1, y2:0, stop:0 #e65100, stop:1 #ffa000); "        "color: white; font-size: 13pt; font-weight: 600; padding: 18px 24px; } "        "QProgressBar { border: 1px solid #e0cbb9; border-radius: 6px; background: white; height: 18px; "        "text-align: center; } QProgressBar::chunk { background: #e65100; border-radius: 5px; } "        "QPushButton { border-radius: 6px; padding: 9px 22px; font-weight: 600; } "        "QPushButton#glowny { background: #e65100; color: white; border: none; } "        "QPushButton#glowny:disabled { background: #f3c9a4; color: #fff6ee; } "        "QPushButton#drugi { background: white; color: #6d5d52; border: 1px solid #e0cbb9; }")    uklad = QVBoxLayout(okno)    uklad.setContentsMargins(0, 0, 0, 18)    pasek = QLabel("Aktualizacja ustawień komputera")    pasek.setObjectName("pasek")    uklad.addWidget(pasek)    tresc = QVBoxLayout()    tresc.setContentsMargins(26, 16, 26, 6)    tresc.setSpacing(10)    opis = QLabel(powod or TEKST_AKTUALIZACJI)    opis.setWordWrap(True)    opis.setStyleSheet("font-size: 11pt;")    postep = QProgressBar()    postep.setRange(0, 100)    biezacy = QLabel("Pobieram najnowszą wersję programu…")    biezacy.setStyleSheet("color: #e65100; font-weight: 600;")    biezacy.setWordWrap(True)    for w in (opis, postep, biezacy):        tresc.addWidget(w)    uklad.addLayout(tresc)    dol = QHBoxLayout()    dol.setContentsMargins(26, 4, 26, 0)    dol.addStretch(1)    restart = QPushButton("Uruchom ponownie")    restart.setObjectName("drugi")    restart.hide()    zamknij = QPushButton("Zamknij")    zamknij.setObjectName("glowny")    zamknij.setEnabled(False)    dol.addWidget(restart)    dol.addWidget(zamknij)    uklad.addLayout(dol)    zamknij.clicked.connect(okno.accept)    restart.clicked.connect(lambda: (uruchom(["systemctl", "reboot"], sprawdz=False, cicho=True), okno.accept()))    stan = {"pozycja": 0, "tytuly": {}, "start": time.monotonic(), "koniec": False}    def koniec(tekst: str, kolor: str = "#2e7d32") -> None:        stan["koniec"] = True        zegar.stop()        biezacy.setText(tekst)        biezacy.setStyleSheet(f"color: {kolor}; font-weight: 600;")        opis.setText("Część zmian zadziała w pełni po ponownym uruchomieniu komputera.")        zamknij.setEnabled(True)        restart.show()    def odswiez() -> None:        try:            with open(plik_logu, encoding="utf-8", errors="replace") as plik:                plik.seek(stan["pozycja"])                dane = plik.read()        except OSError:            if time.monotonic() - stan["start"] > 60:                koniec("Nie udało się uruchomić aktualizacji. Spróbuj ponownie po zalogowaniu.", "#c62828")            return        pelne = dane[:dane.rfind("\n") + 1]        stan["pozycja"] += len(pelne.encode("utf-8"))        for linia in pelne.splitlines():            if not linia.startswith(PREFIKS_ZDARZENIA):                continue            try:                z = json.loads(linia[len(PREFIKS_ZDARZENIA):])            except ValueError:                continue            if z.get("typ") == "lista_krokow":                stan["tytuly"] = {x["id"]: x["tytul"] for x in z.get("kroki", [])}            elif z.get("typ") == "krok" and z.get("stan") == "trwa":                biezacy.setText(stan["tytuly"].get(z.get("id"), z.get("id", "")) + "…")            elif z.get("typ") == "postep":                postep.setValue(int(z.get("procent", 0)))            elif z.get("typ") == "koniec":                postep.setValue(100)                bledy = z.get("podsumowanie", {}).get("blad", 0)                if bledy:                    koniec("Zakończono, ale nie wszystko się udało: " + "; ".join(z.get("uwagi", [])[:3]),                           "#c62828")                else:                    koniec("Gotowe – ustawienia komputera są aktualne.")    def zamkniecie(zdarzenie) -> None:          # podczas pracy okna nie zamykamy (usługa i tak działa)        if stan["koniec"]:            zdarzenie.accept()        else:            zdarzenie.ignore()    okno.closeEvent = zamkniecie    zegar = QTimer(okno)    zegar.timeout.connect(odswiez)    zegar.start(700)    okno.setMinimumWidth(560)    okno.adjustSize()    ekran = QGuiApplication.primaryScreen().availableGeometry()    okno.move(ekran.center() - okno.rect().center())    okno.setWindowFlag(Qt.WindowType.WindowStaysOnTopHint, False)    okno.exec()def podpis_poprawny(dane: bytes, podpis: bytes, klucz: str = "") -> bool:    """Sprawdza podpis Ed25519 (klucz: SubjectPublicKeyInfo w base64, jak w KLUCZ_PODPISU).    Najpierw biblioteką cryptography (jeśli jest), potem poleceniem openssl. Brak narzędzia = brak    zgody na uruchomienie (bezpieczniej użyć zainstalowanej wersji)."""    klucz = klucz or KLUCZ_PODPISU    if not klucz or len(podpis) != 64:        return False    try:        der = base64.b64decode(klucz, validate=True)    except ValueError:        return False    try:        from cryptography.hazmat.primitives.serialization import load_der_public_key        from cryptography.exceptions import InvalidSignature        try:            load_der_public_key(der).verify(podpis, dane)            return True        except (InvalidSignature, ValueError, TypeError):            return False    except ImportError:        pass    if not shutil.which("openssl"):        return False    with tempfile.TemporaryDirectory(prefix="jk-podpis-") as katalog:        sciezki = {n: os.path.join(katalog, n) for n in ("klucz.pem", "dane", "podpis")}        with open(sciezki["klucz.pem"], "w", encoding="ascii") as f:            f.write("-----BEGIN PUBLIC KEY-----\n" + klucz + "\n-----END PUBLIC KEY-----\n")        with open(sciezki["dane"], "wb") as f:            f.write(dane)        with open(sciezki["podpis"], "wb") as f:            f.write(podpis)        wynik = subprocess.run(["openssl", "pkeyutl", "-verify", "-pubin", "-inkey", sciezki["klucz.pem"],                                "-rawin", "-in", sciezki["dane"], "-sigfile", sciezki["podpis"]],                               stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)        return wynik.returncode == 0def pobierz_bajty(adres: str, limit: int, czas: int = 60) -> bytes:    zadanie_http = urllib.request.Request(adres, headers={"User-Agent": USER_AGENT})    with urllib.request.urlopen(zadanie_http, timeout=czas) as odp:        return odp.read(limit)def aktualizacja_pobierz(zadanie: str) -> int:    """(usługa, root) Pobiera najnowszy program z serwera i uruchamia nim rekonfigurację.    Gdy pobranie się nie uda – rekonfiguracja wersją zainstalowaną."""    if not WZORZEC_ZADANIA.fullmatch(zadanie):        return 1    nowy = os.path.join(KATALOG_STANU, "optymalizator-najnowszy.py")    try:        kod = pobierz_bajty(ADRES_PROGRAMU, 20 * 1024 * 1024)        if KLUCZ_PODPISU:            # Pobrana wersja uruchomi się tylko z poprawnym podpisem Jabłoński KOMPUTERY            if not podpis_poprawny(kod, pobierz_bajty(ADRES_PODPISU, 1024, 30)):                raise ValueError("podpis cyfrowy nie zgadza się")            print("Podpis cyfrowy nowej wersji: poprawny.", flush=True)        tekst = kod.decode("utf-8")        if "Optymalizator - Jabłoński KOMPUTERY" not in tekst:            raise ValueError("to nie jest program Optymalizator")        compile(tekst, nowy, "exec")                  # błąd składni = nie uruchamiamy        os.makedirs(KATALOG_STANU, exist_ok=True)        with open(nowy, "wb") as plik:            plik.write(kod)        os.chmod(nowy, 0o700)        os.execv(sys.executable, [sys.executable, nowy, "--aktualizacja-teraz", zadanie])    except (OSError, ValueError, SyntaxError, urllib.error.URLError) as e:        print(f"Nie udało się pobrać najnowszej wersji ({e}) – używam zainstalowanej.", file=sys.stderr)    return aktualizacja_wykonaj(zadanie)def aktualizacja_wykonaj(zadanie: str) -> int:    """(root) Rekonfiguracja bez pytań: opcje z licencji, wybory zapamiętane przy ostatniej konfiguracji.    Nowa opcja w pakiecie: gry – tak, Logitech – podłączone urządzenia. Usunięte opcje sprząta wykonawca.    nVidia Unlock RTX tylko gdy klient wcześniej świadomie się zgodził."""    m = WZORZEC_ZADANIA.fullmatch(zadanie)    licencja = wczytaj_licencje()    if not m or not licencja:        return 1    try:                                              # kto kliknął „Tak” – jego sesja dostaje ustawienia od razu        p = pwd.getpwuid(int(m.group(1)))        uzytkownik = p.pw_name if p.pw_uid >= 1000 else None    except KeyError:        uzytkownik = None    wybory = licencja.get("wybory") or {}    poprzednie = set(licencja.get("opcje") or [])    nazwa = licencja.get("nazwa") or obecna_nazwa_komputera()    ok, komunikat, opcje = aktywuj_licencje(licencja["klucz"], nazwa)    if not ok:        global RAPORT        RAPORT = Raport("json")        RAPORT.zdarzenie({"typ": "koniec", "uwagi": [komunikat],                          "podsumowanie": {"ok": 0, "ostrzezenie": 0, "blad": 1, "pominiety": 0}})        return 4    gry = bool(wybory.get("gry", True)) if "gry" in poprzednie else True    logitech = [u for u in wybory.get("logitech", []) if u in opcje]    logitech += [u for u in wykryj_logitech() if u in opcje and u not in poprzednie and u not in logitech]    return uruchom_wykonawce(bool(wybory.get("numlock", True)), uzytkownik or wybory.get("uzytkownik") or None,                             "json", licencja.get("nazwa") or None, True, licencja["klucz"], logitech, gry,                             opcje, bool(wybory.get("nvidia_rtx", False)),                             bool(wybory.get("antykradziez", antykradziez_wlaczona())), dict(OSTATNIA_GRAFIKA))WZORZEC_LINKU = re.compile(r"\b(?:https?|ftp)://[^\s<>\"']+", re.IGNORECASE)def tekst_z_linkami(tekst: str) -> str:    """Zwykły tekst komunikatu → HTML: znaki specjalne zabezpieczone, nowe linie zachowane,    adresy http://, https:// i ftp:// zamienione w klikalne linki."""    wynik, poprzedni = [], 0    for m in WZORZEC_LINKU.finditer(tekst):        adres = m.group(0)        koniec = m.end()        while adres and adres[-1] in ".,;:!?)]}":        # interpunkcja po linku nie jest jego częścią            if adres[-1] == ")" and adres.count("(") >= adres.count(")"):                break            adres, koniec = adres[:-1], koniec - 1        wynik.append(html.escape(tekst[poprzedni:m.start()]))        wynik.append(f'<a href="{html.escape(adres, quote=True)}" style="color:#e65100;">'                     f'{html.escape(adres)}</a>')        poprzedni = koniec    wynik.append(html.escape(tekst[poprzedni:]))    return "".join(wynik).replace("\n", "<br>")def jasny_kolor(kod: str) -> bool:    """Czy na tym kolorze lepiej czytać ciemny napis (jasność postrzegana)."""    r, g, b = (int(kod[i:i + 2], 16) for i in (0, 2, 4))    return 0.299 * r + 0.587 * g + 0.114 * b > 150def uruchom_okno_podswietlenia() -> int:    """Okno wyboru koloru i efektu podświetlenia G213 / G102 (działa jako zwykły użytkownik)."""    try:        from PyQt6.QtCore import Qt        from PyQt6.QtGui import QColor        from PyQt6.QtWidgets import (QApplication, QColorDialog, QComboBox, QGridLayout,                                     QHBoxLayout, QLabel, QPushButton, QVBoxLayout, QWidget)    except ImportError:        print("Brak PyQt6 (pakiet python3-pyqt6).", file=sys.stderr)        return 1    KOLORY = [("Pomarańczowy J.K.", "f67400"), ("Czerwony", "ff0000"), ("Zielony", "00ff00"),              ("Niebieski", "0040ff"), ("Turkusowy", "00ffd0"), ("Fioletowy", "a000ff"),              ("Różowy", "ff2080"), ("Żółty", "ffd000"), ("Biały", "ffffff")]    app = QApplication.instance() or QApplication(sys.argv)    app.setApplicationName("jk-podswietlenie")    app.setDesktopFileName("jablonski-podswietlenie")    ust = wczytaj_podswietlenie()    okno = QWidget()    okno.setWindowTitle(f"{PODSWIETLENIE_NAZWA} – Jabłoński KOMPUTERY")    okno.setStyleSheet(        "QWidget { background: #fdf8f4; color: #2b2522; font-size: 11pt; } "        "QLabel#naglowek { background: qlineargradient(x1:0, y1:0, x2:1, y2:0, stop:0 #e65100, "        "stop:1 #ffa000); color: white; font-size: 15pt; font-weight: 600; padding: 16px 20px; } "        "QPushButton { background: white; border: 1px solid #e3cbb8; border-radius: 6px; padding: 8px 14px; } "        "QPushButton:hover { border-color: #e65100; } "        "QPushButton#zastosuj { background: #e65100; color: white; border: none; font-weight: 600; "        "padding: 10px 26px; } QPushButton#zastosuj:hover { background: #bf360c; } "        "QComboBox { background: white; border: 1px solid #e3cbb8; border-radius: 6px; padding: 6px 10px; }")    uklad = QVBoxLayout(okno)    uklad.setContentsMargins(0, 0, 0, 16)    naglowek = QLabel(PODSWIETLENIE_NAZWA)    naglowek.setObjectName("naglowek")    uklad.addWidget(naglowek)    tresc = QVBoxLayout()    tresc.setContentsMargins(22, 14, 22, 0)    tresc.setSpacing(12)    uklad.addLayout(tresc)    wykryte = wykryj_logitech()    nazwy = [LOGITECH[i][0] for i in ("g213", "g102") if i in wykryte]    stan_urzadzen = QLabel("Podłączone: " + (", ".join(nazwy) if nazwy else                           "nie wykryto G213 ani G102 – podłącz klawiaturę lub mysz"))    stan_urzadzen.setWordWrap(True)    tresc.addWidget(stan_urzadzen)    podglad = QLabel()    podglad.setFixedHeight(46)    podglad.setAlignment(Qt.AlignmentFlag.AlignCenter)    tresc.addWidget(podglad)    def odswiez_podglad():        jasny = jasny_kolor(ust["kolor"])        podglad.setText(f"#{ust['kolor'].upper()}  •  {PODSWIETLENIE_EFEKTY[ust['efekt']]}")        podglad.setStyleSheet(f"background: #{ust['kolor']}; border-radius: 8px; font-weight: 600; "                              f"color: {'#2b2522' if jasny else 'white'};")    siatka = QGridLayout()    for n, (nazwa_k, kod) in enumerate(KOLORY):        b = QPushButton(nazwa_k)        jasny = jasny_kolor(kod)        b.setStyleSheet(f"background: #{kod}; color: {'#2b2522' if jasny else 'white'}; "                        "border: 1px solid #d8c3b2; font-weight: 600;")        b.clicked.connect(lambda _=False, c=kod: (ust.update(kolor=c), odswiez_podglad()))        siatka.addWidget(b, n // 3, n % 3)    tresc.addLayout(siatka)    inny = QPushButton("Inny kolor…")    def wybierz_inny():        c = QColorDialog.getColor(QColor("#" + ust["kolor"]), okno, "Wybierz kolor podświetlenia")        if c.isValid():            ust["kolor"] = c.name()[1:].lower()            odswiez_podglad()    inny.clicked.connect(wybierz_inny)    tresc.addWidget(inny)    wiersz = QHBoxLayout()    wiersz.addWidget(QLabel("Efekt:"))    efekty = QComboBox()    for klucz_e, nazwa_e in PODSWIETLENIE_EFEKTY.items():        efekty.addItem(nazwa_e, klucz_e)    efekty.setCurrentIndex(list(PODSWIETLENIE_EFEKTY).index(ust["efekt"]))    efekty.currentIndexChanged.connect(lambda _: (ust.update(efekt=efekty.currentData()),                                                  odswiez_podglad()))    wiersz.addWidget(efekty, 1)    tresc.addLayout(wiersz)    wynik = QLabel("Kolor zapisze się i będzie ustawiany sam przy każdym starcie komputera.")    wynik.setWordWrap(True)    wynik.setStyleSheet("color: #6d5d52; font-size: 10pt;")    tresc.addWidget(wynik)    dol = QHBoxLayout()    wylacz = QPushButton("Wyłącz podświetlenie")    zastosuj = QPushButton("Zastosuj")    zastosuj.setObjectName("zastosuj")    def zastosuj_teraz(wylaczone: bool = False):        biezace = dict(ust, kolor="000000", efekt="staly") if wylaczone else dict(ust)        komunikaty = zastosuj_podswietlenie(biezace)        try:            with open(PODSWIETLENIE_PLIK, "w", encoding="utf-8") as plik:                json.dump(biezace, plik)            zapisano = "Zapisano – tak będzie też po ponownym uruchomieniu."        except OSError:            zapisano = "Nie udało się zapisać ustawień na przyszłość (brak uprawnień)."        wynik.setText(" • ".join(komunikaty) + "\n" + zapisano)    wylacz.clicked.connect(lambda: zastosuj_teraz(True))    zastosuj.clicked.connect(lambda: zastosuj_teraz())    dol.addWidget(wylacz)    dol.addStretch(1)    dol.addWidget(zastosuj)    tresc.addLayout(dol)    odswiez_podglad()    okno.resize(560, 520)    okno.show()    return app.exec()def pokaz_komunikaty(komunikaty: List[Dict[str, str]]) -> List[str]:    """Wyświetla komunikaty po kolei na środku ekranu. Zwraca identyfikatory    komunikatów jednorazowych zamkniętych przyciskiem OK."""    from PyQt6.QtCore import QRectF, Qt    from PyQt6.QtGui import QBrush, QColor, QFont, QGuiApplication, QLinearGradient, QPainter    from PyQt6.QtWidgets import (QApplication, QDialog, QHBoxLayout, QLabel, QPushButton,                                 QVBoxLayout, QWidget)    class Pasek(QWidget):        def __init__(self):            super().__init__()            self.setFixedHeight(64)        def paintEvent(self, _z):            p = QPainter(self)            p.setRenderHint(QPainter.RenderHint.Antialiasing)            g = QLinearGradient(0, 0, self.width(), 0)            g.setColorAt(0, QColor("#e65100"))            g.setColorAt(1, QColor("#ffa000"))            p.fillRect(self.rect(), QBrush(g))            p.setBrush(QColor("white"))            p.setPen(Qt.PenStyle.NoPen)            p.drawRoundedRect(QRectF(16, 12, 40, 40), 9, 9)            f = QFont()            f.setBold(True)            f.setPixelSize(17)            p.setFont(f)            p.setPen(QColor("#e65100"))            p.drawText(QRectF(16, 12, 40, 40), Qt.AlignmentFlag.AlignCenter, "JK")            f.setPixelSize(16)            p.setFont(f)            p.setPen(QColor("white"))            p.drawText(QRectF(70, 0, self.width() - 80, 64),                       Qt.AlignmentFlag.AlignVCenter, "Wiadomość od Jabłoński KOMPUTERY")            p.end()    app = QApplication.instance() or QApplication(sys.argv)    app.setApplicationName("jk-komunikaty")    odczytane = []    for m in komunikaty:        okno = QDialog()        okno.setWindowTitle("Jabłoński KOMPUTERY – wiadomość")        okno.setWindowFlag(Qt.WindowType.WindowStaysOnTopHint, True)        okno.setStyleSheet("QDialog { background: #fdf8f4; } QLabel { color: #2b2522; } "                           "QPushButton { background: #e65100; color: white; border: none; "                           "border-radius: 6px; padding: 9px 30px; font-weight: 600; } "                           "QPushButton:hover { background: #bf360c; }")        uklad = QVBoxLayout(okno)        uklad.setContentsMargins(0, 0, 0, 18)        uklad.addWidget(Pasek())        tresc = QVBoxLayout()        tresc.setContentsMargins(26, 16, 26, 6)        if m.get("tytul"):            tytul = QLabel(m["tytul"])            tytul.setWordWrap(True)            tytul.setStyleSheet("font-size: 16pt; font-weight: 600;")            tresc.addWidget(tytul)        tekst = QLabel(tekst_z_linkami(m.get("tresc", "")))        tekst.setWordWrap(True)        tekst.setTextFormat(Qt.TextFormat.RichText)        tekst.setOpenExternalLinks(True)               # link otwiera domyślna przeglądarka / KDE        tekst.setTextInteractionFlags(Qt.TextInteractionFlag.TextBrowserInteraction)        tekst.setStyleSheet("font-size: 12pt;")        tresc.addWidget(tekst)        uklad.addLayout(tresc)        dol = QHBoxLayout()        dol.addStretch(1)        ok = QPushButton("OK")        ok.setDefault(True)        ok.clicked.connect(okno.accept)        dol.addWidget(ok)        dol.addSpacing(26)        uklad.addLayout(dol)        okno.setMinimumWidth(560)        okno.adjustSize()        ekran = QGuiApplication.primaryScreen().availableGeometry()   # środek ekranu (X11;        okno.move(ekran.center() - okno.rect().center())          # pod Wayland układa KWin)        if okno.exec() == QDialog.DialogCode.Accepted and m.get("typ") == "jednorazowy":            odczytane.append(m["id"])    return odczytane# ============================================================================# 11. MAIN# ============================================================================def uzupelnij_path() -> None:    """„su root -c …” zostawia PATH zwykłego użytkownika, a w Debianie nie ma w nim    katalogów sbin (usermod, runuser, visudo, update-grub…). Dopisujemy je zawsze."""    obecne = os.environ.get("PATH", "").split(os.pathsep)    brakujace = [k for k in ("/usr/local/sbin", "/usr/local/bin", "/usr/sbin", "/usr/bin",                             "/sbin", "/bin") if k not in obecne]    os.environ["PATH"] = os.pathsep.join([p for p in obecne if p] + brakujace)def main() -> int:    global SYMULACJA    uzupelnij_path()    parser = argparse.ArgumentParser(description=NAZWA_PROGRAMU)    parser.add_argument("--symulacja", action="store_true",                        help="pokaż, co zostałoby zrobione – bez zmian w systemie")    parser.add_argument("--konsola", action="store_true", help="tryb tekstowy")    parser.add_argument("--ryzyko", action="store_true",                        help="potwierdzam uruchomienie na systemie innym niż Debian 13")    # wewnętrzne (program wywołuje sam siebie)    ukryty = argparse.SUPPRESS    parser.add_argument("--worker", action="store_true", help=ukryty)    parser.add_argument("--numlock", choices=["tak", "nie"], default="tak", help=ukryty)    parser.add_argument("--uzytkownik", default=None, help=ukryty)    parser.add_argument("--nazwa", default=None, help=ukryty)    parser.add_argument("--przygotuj", metavar="KONTO", default=None, help=ukryty)    parser.add_argument("--przygotowano", action="store_true", help=ukryty)    parser.add_argument("--sesja", action="store_true", help=ukryty)    parser.add_argument("--wymus", action="store_true", help=ukryty)    parser.add_argument("--zloz-logo", nargs="+", metavar="PLIK", default=None, help=ukryty)    parser.add_argument("--klucz", default=None, help=ukryty)    parser.add_argument("--zglos-start", action="store_true", help=ukryty)    parser.add_argument("--komunikaty", action="store_true", help=ukryty)    parser.add_argument("--stan", action="store_true", help=ukryty)    parser.add_argument("--aktualizacja", default=None, help=ukryty)    parser.add_argument("--aktualizacja-teraz", default=None, help=ukryty)    parser.add_argument("--logitech", default="", help=ukryty)    parser.add_argument("--gry", choices=["tak", "nie"], default="tak", help=ukryty)    parser.add_argument("--opcje", default=",".join(OPCJE_PROGRAMU), help=ukryty)    parser.add_argument("--podswietlenie", action="store_true", help=ukryty)    parser.add_argument("--podswietlenie-start", action="store_true", help=ukryty)    parser.add_argument("--dell-pin-id", action="store_true", help=ukryty)    parser.add_argument("--nvidia-rtx", choices=["tak", "nie"], default="nie", help=ukryty)    parser.add_argument("--antykradziez", choices=["tak", "nie"], default="nie", help=ukryty)    parser.add_argument("--grafika", default="{}", help=ukryty)    parser.add_argument("--konwertuj-obraz", nargs=2, metavar="PLIK", default=None, help=ukryty)    parser.add_argument("--napraw", action="store_true", help=ukryty)    args = parser.parse_args()    SYMULACJA = args.symulacja    if args.zglos_start:                 # (usługa systemowa) zgłoszenie uruchomienia komputera        return zglos_uruchomienie()    if args.stan:                        # (usługa systemowa) pakiet i tryb „zgubiony”        return sprawdz_stan()    if args.aktualizacja:                # (usługa systemowa) pobranie najnowszego programu…        return aktualizacja_pobierz(args.aktualizacja)    if args.aktualizacja_teraz:          # …i rekonfiguracja bez pytań        return aktualizacja_wykonaj(args.aktualizacja_teraz)    if args.komunikaty:                  # (autostart w sesji) komunikaty z panelu        return uruchom_komunikaty()    if args.podswietlenie:               # okno „Podświetlenie Logitech”        return uruchom_okno_podswietlenia()    if args.dell_pin_id:                 # (usługa systemowa) DELL Unlock Pin ID        return uruchom_dell_pin_id()    if args.podswietlenie_start:         # (usługa systemowa) kolor Logitech przy starcie        return uruchom_podswietlenie_start()    if args.konwertuj_obraz:             # pomocnicze: PNG → JPG (tapeta)        return konwertuj_obraz(*args.konwertuj_obraz)    if args.napraw:                      # (menu) „Aktualizuj ustawienia” – naprawa jak przy instalacji        return uruchom_naprawe()    if args.zloz_logo:                   # pomocnicze: składanie logo „O tym systemie”        return zloz_logo(args.zloz_logo[0], *args.zloz_logo[1:])    if args.sesja:                       # ustawienia konta, przy logowaniu        return uruchom_tryb_sesji(args.wymus)    if args.przygotuj:                   # (root) przygotowanie przed oknem        return przygotuj_dla_uzytkownika(args.przygotuj)    if args.worker:                      # (root) część administracyjna, uruchamiana przez pkexec        if os.geteuid() != 0 and not SYMULACJA:            print("Wykonawca wymaga uprawnień administratora.", file=sys.stderr)            return 1        signal.signal(signal.SIGHUP, signal.SIG_IGN)    # zamknięcie Konsoli nie przerwie instalacji        return uruchom_wykonawce(args.numlock == "tak", args.uzytkownik, "json", args.nazwa,                                 args.ryzyko, normalizuj_klucz(args.klucz or ""),                                 [u for u in args.logitech.split(",") if u], args.gry == "tak",                                 [o for o in args.opcje.split(",") if o], args.nvidia_rtx == "tak",                                 args.antykradziez == "tak", wczytaj_grafike_z_argumentu(args.grafika))    if args.konsola:        if os.geteuid() != 0 and not SYMULACJA:            if not sprawdz_system_w_terminalu(args):                return 1            return uruchom_jako_root(["/usr/bin/python3", SKRYPT, "--konsola",                                      "--uzytkownik", getpass.getuser(), *dodatkowe_argumenty(args)])        return uruchom_tryb_tekstowy(args)    if os.geteuid() == 0:        return start_jako_root(args)    return uruchom_gui(args)if __name__ == "__main__":    sys.exit(main())