🔒 Repository is read-only – file editing is disabled.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703
#!/bin/sh
# Sesja środowiska Luna — uruchamia kompozytor Selene.
#
# Domyślnie startujemy na DRM/KMS (własny ekran, bez nadrzędnego kompozytora).
# Gdy master DRM trzyma inna sesja, Selene sam to zgłosi i spadnie do wyjścia
# nested — ustaw wtedy SELENE_BACKEND=nested (albo wyloguj bieżącą sesję).
set -eu
# Ctrl+C / Ctrl+\ w terminalu nie mogą kończyć sesji. Sygnały z terminala trafiają
# do grupy procesów, w której działają też selene i luna-shell — ignorujemy je tutaj,
# a dzieci dziedziczą SIG_IGN. Dziecko PTY w luna-terminal resetuje SIGINT do SIG_DFL,
# więc powłoka w terminalu nadal normalnie dostaje przerwanie.
#
# Sama ignorancja nie wystarczała: konsola jądra wysyłała SIGINT do procesu `greetd`
# nadzorującego sesję (logind kończył wtedy sesję = „wylogowanie”). Dlatego Selene
# przejmuje pierwszy plan VT (zob. `selene/src/vt.rs`).
trap '' INT QUIT
# Diagnostyka: gdy sesję kończy sygnał (np. `loginctl terminate-session` z menu
# zasilania albo greeter), w logu zostaje ślad — bez tego sesja po prostu znikała.
trap 'ts "sygnał TERM — kończę sesję"; exit 143' TERM
trap 'ts "sygnał HUP — kończę sesję"; exit 129' HUP
export XDG_CURRENT_DESKTOP=Luna
# Pełny, przewidywalny PATH: menedżery logowania potrafią go obciąć (bez `/usr/sbin`
# nie uruchomi się np. `thunar` czy `xclock`, bo ich binarki tam leżą).
export PATH="/usr/local/bin:/usr/bin:/bin:/usr/local/sbin:/usr/sbin:/sbin${PATH:+:$PATH}"
# Powłoka użytkownika: greetd/menedżery logowania NIE eksportują SHELL.
# Bez tego luna-terminal (czyta $SHELL) uruchamiał /bin/sh zamiast zsh.
if [ -z "${SHELL:-}" ]; then
SHELL="$(awk -F: -v u="$(id -un)" '$1==u {print $7; exit}' /etc/passwd 2>/dev/null)"
[ -n "$SHELL" ] || SHELL=/bin/sh
export SHELL
fi
export XDG_SESSION_TYPE=wayland
export XDG_SESSION_DESKTOP=Luna
# XDG_RUNTIME_DIR normalnie ustawia menedżer sesji (logind/pam_systemd). Gdy go brak
# (np. pam_systemd nie zdołał założyć sesji), wskazujemy katalog per-uid, żeby Selene
# i klienci mieli gdzie założyć gniazdo Wayland. Selene sam waliduje ten katalog.
if [ -z "${XDG_RUNTIME_DIR:-}" ] && [ -d "/run/user/$(id -u)" ]; then
XDG_RUNTIME_DIR="/run/user/$(id -u)"
export XDG_RUNTIME_DIR
fi
: "${SELENE_BACKEND:=drm}"
export SELENE_BACKEND
# Tryb DRM nie ma nadrzędnego kompozytora — wejście czytamy wprost z /dev/input
# (wymaga dostępu do urządzeń: grupa `input` albo root).
if [ "$SELENE_BACKEND" = "drm" ]; then
: "${SELENE_INPUT:=evdev}"
export SELENE_INPUT
fi
# GPU: domyślnie włączone (`LUNA_GPU=1`), z automatycznym fallbackiem do CPU w Selene,
# jeśli EGL nie jest dostępny. W razie problemów na konkretnym sterowniku można
# wymusić tryb czysto programowy przez `LUNA_GPU=0 luna-session`.
: "${LUNA_GPU:=1}"
export LUNA_GPU
# NVIDIA: VA-API przez NVDEC (pakiet `nvidia-vaapi-driver`). Sterowniki 525+
# mają zepsuty backend EGL tego drivera, więc jedyną działającą ścieżką jest
# `direct` (wymaga `nvidia_drm.modeset=1`). Zmienne są obojętne dla innych kart,
# a `LIBVA_DRIVER_NAME` ustawiamy **tylko** gdy driver naprawdę leży na dysku —
# inaczej zepsulibyśmy VA-API na Intelu/AMD.
if [ -e /sys/module/nvidia ] || [ -e /proc/driver/nvidia ]; then
: "${NVD_BACKEND:=direct}"
export NVD_BACKEND
if [ -f /usr/lib/dri/nvidia_drv_video.so ] || [ -f /usr/lib64/dri/nvidia_drv_video.so ]; then
: "${LIBVA_DRIVER_NAME:=nvidia}"
# Sandbox procesu RDD odcina /dev/nvidia* — bez tego Firefox/Zen nie
# zainicjuje VA-API mimo poprawnej konfiguracji.
: "${MOZ_DISABLE_RDD_SANDBOX:=1}"
export LIBVA_DRIVER_NAME MOZ_DISABLE_RDD_SANDBOX
fi
fi
# Diagnostyka wydajności (fps DRM + tempo kursora w Selene, fps powłoki w luna-shell).
# Domyślnie **włączona**, bo log sesji jest trwały i tylko wtedy da się po fakcie ustalić,
# gdzie znikają klatki. Wyłącz jawnie wolnym zerem: SELENE_STATS=0 LUNA_STATS=0 luna-session
: "${SELENE_STATS:=1}"
: "${LUNA_STATS:=1}"
export SELENE_STATS LUNA_STATS
# Binarki zainstalowane przez użytkownika (np. `install -m755 ... ~/.local/bin`)
# mają pierwszeństwo przed systemowymi — pozwala to testować/aktualizować Lunę
# bez roota, a sesja zawsze uruchamia najnowszą powłokę i kompozytor. Robimy to
# **przed** logiem, żeby `command -v selene` pokazywał faktycznie uruchomiony plik
# (wcześniej log twierdził `"/usr/bin/selene"`, a proces brał starszy z `~/.local/bin`).
export PATH="$HOME/.local/bin:$PATH"
# Trwały log sesji: LightDM trzyma tylko 2 pliki `.xsession-errors` i obraca je przy
# każdym starcie sesji, przez co logi Luny przepadają. Piszemy do stałego pliku w
# katalogu stanu użytkownika, żeby każdą próbę dało się obejrzeć po fakcie.
log_dir="${XDG_STATE_HOME:-$HOME/.local/state}/luna"
if mkdir -p "$log_dir" 2>/dev/null; then
log="$log_dir/session.log"
# Pochodzenie binarek: który plik i z jaką datą faktycznie wystartował. Bez tego
# łatwo testować stary build i szukać błędu, którego już nie ma.
selene_path="$(command -v selene 2>/dev/null || echo '<brak>')"
shell_path="$(command -v luna-shell 2>/dev/null || echo '<brak>')"
printf '=== luna-session %s ===\nXDG_RUNTIME_DIR=%s SELENE_BACKEND=%s SELENE_INPUT=%s\nselene: %s [%s]\nluna-shell: %s [%s]\nSELENE_STATS=%s LUNA_STATS=%s LUNA_GPU=%s\n' \
"$(date -Is)" "${XDG_RUNTIME_DIR:-<brak>}" "$SELENE_BACKEND" "${SELENE_INPUT:-<brak>}" \
"$selene_path" "$(stat -c %y "$selene_path" 2>/dev/null | cut -d. -f1 || echo '?')" \
"$shell_path" "$(stat -c %y "$shell_path" 2>/dev/null | cut -d. -f1 || echo '?')" \
"$SELENE_STATS" "$LUNA_STATS" "${LUNA_GPU:-<brak>}" \
>>"$log" 2>/dev/null || true
exec >>"$log" 2>&1
fi
# Kompozytor w tle, a po nim powłoka Luna (panel/OSD).
rt="${XDG_RUNTIME_DIR:-/run/user/$(id -u)}"
ts() { printf '%s luna-session: %s\n' "$(date +%H:%M:%S)" "$*"; }
# Start licznika całej sesji (od pierwszych instrukcji skryptu), żeby w logu
# było widać pełny czas „logowanie → działający panel”, a nie tylko fragment.
t_session="$(date +%s%3N 2>/dev/null || echo 0)"
# `locale -a` wypisuje `pl_PL.utf8`, a my używamy tagów typu `pl_PL.UTF-8`.
# Porównujemy po usunięciu myślników i wielkości liter.
has_locale() {
[ -n "$1" ] || return 1
command -v locale >/dev/null 2>&1 || return 1
# Lista generowanych locale jest stała w czasie sesji, a `locale -a` to
# osobny proces (kilka–kilkadziesiąt ms). Pytamy raz i trzymamy wynik.
if [ -z "${locales_ready:-}" ]; then
locales_list="$(locale -a 2>/dev/null | tr '[:upper:]' '[:lower:]' | tr -d '-')"
locales_ready=1
fi
norm="$(printf '%s' "$1" | tr '[:upper:]' '[:lower:]' | tr -d '-')"
printf '%s\n' "$locales_list" | grep -Fxq "$norm"
}
# Język wybrany w Ustawieniach Luny. Ustawiamy `LANGUAGE` (gettext) i — gdy locale
# jest wygenerowane — `LANG`; reszta aplikacji libLuny czyta ten sam plik sama.
luna_locale_file="${XDG_CONFIG_HOME:-$HOME/.config}/luna/locale.conf"
if [ -r "$luna_locale_file" ]; then
luna_lang="$(sed -n 's/^[[:space:]]*language[[:space:]]*=[[:space:]]*//p' "$luna_locale_file" | head -n 1 | tr -d '[:space:]')"
case "$luna_lang" in
pl) luna_locale="pl_PL.UTF-8" ;;
en) luna_locale="en_US.UTF-8" ;;
de) luna_locale="de_DE.UTF-8" ;;
fr) luna_locale="fr_FR.UTF-8" ;;
es) luna_locale="es_ES.UTF-8" ;;
pt) luna_locale="pt_PT.UTF-8" ;;
it) luna_locale="it_IT.UTF-8" ;;
nl) luna_locale="nl_NL.UTF-8" ;;
ru) luna_locale="ru_RU.UTF-8" ;;
uk) luna_locale="uk_UA.UTF-8" ;;
tr) luna_locale="tr_TR.UTF-8" ;;
sv) luna_locale="sv_SE.UTF-8" ;;
cs) luna_locale="cs_CZ.UTF-8" ;;
sw) luna_locale="sw_KE.UTF-8" ;;
*) luna_locale="" ;;
esac
if [ -n "$luna_lang" ]; then
export LANGUAGE="$luna_lang"
if [ -n "$luna_locale" ] && has_locale "$luna_locale"; then
export LANG="$luna_locale"
elif [ -n "$luna_locale" ] && [ -d "$HOME/.local/share/locale/$luna_locale" ]; then
# Locale wygenerowane bez roota przez Ustawienia (`localedef`).
export LANG="$luna_locale"
export LOCPATH="$HOME/.local/share/locale"
fi
ts "język z Ustawień: $luna_lang${luna_locale:+ ($luna_locale)}"
fi
fi
# Region, formaty i strefa czasowa z Ustawień Luny (`region.conf`).
# To ustawienia użytkownika — nie wymagają roota; systemowa strefa zostaje nietknięta.
luna_region_file="${XDG_CONFIG_HOME:-$HOME/.config}/luna/region.conf"
if [ -r "$luna_region_file" ]; then
luna_region_locale="$(sed -n 's/^[[:space:]]*locale[[:space:]]*=[[:space:]]*//p' "$luna_region_file" | head -n 1 | tr -d '[:space:]')"
luna_region_tz="$(sed -n 's/^[[:space:]]*timezone[[:space:]]*=[[:space:]]*//p' "$luna_region_file" | head -n 1 | tr -d '[:space:]')"
if [ -n "$luna_region_locale" ]; then
if has_locale "$luna_region_locale"; then
export LC_TIME="$luna_region_locale"
elif [ -d "$HOME/.local/share/locale/$luna_region_locale" ]; then
export LC_TIME="$luna_region_locale"
export LOCPATH="$HOME/.local/share/locale"
ts "format czasu z Ustawień: $luna_region_locale"
else
ts "locale z Ustawień niewygenerowane: $luna_region_locale (pomijam)"
fi
fi
if [ -n "$luna_region_tz" ] && [ -f "/usr/share/zoneinfo/$luna_region_tz" ]; then
export TZ="$luna_region_tz"
ts "strefa czasowa z Ustawień: $luna_region_tz"
fi
fi
# Język ma obowiązywać w **całej sesji**, nie tylko w aplikacjach libLuny.
# `dbus-update-activation-environment` / `systemctl --user import-environment`
# wykonujemy w tle, razem z resztą środowiska (niżej) — wywołane tutaj, przed
# powłoką, potrafią czekać na start menedżera użytkownika nawet kilkadziesiąt
# sekund i przez ten czas widać tylko tapetę. Powłoka dziedziczy `LANGUAGE`
# bezpośrednio z tego procesu, więc niczego nie traci.
ts "uruchamiam selene"
# Znacznik do pomiaru „jak szybko po kompozytorze wstaje panel” w logu sesji.
t0="$(date +%s%3N 2>/dev/null || echo 0)"
# Sprzątanie po poprzedniej sesji: zamki gniazd zostają po nagłym zabiciu kompozytora.
# Katalog jest per-użytkownik, więc nie ruszamy niczego cudzego.
marker="$rt/luna-wayland"
rm -f "$marker" 2>/dev/null || true
# Marker X11 z poprzedniej sesji jest bezużyteczny, a wręcz szkodliwy: sesja
# ustawiłaby `DISPLAY` na ekran, który już nie istnieje (albo o innym numerze),
# zanim nowy Xwayland w ogóle wstanie. Kasujemy zawsze.
rm -f "$rt/luna-display" 2>/dev/null || true
# Liczba monitorów z poprzedniej sesji też jest nieaktualna.
rm -f "$rt/luna-outputs" 2>/dev/null || true
rm -f "$rt"/wayland-*.lock 2>/dev/null || true
# Selene potrzebuje deskryptora terminala sesji, żeby przejąć pierwszy plan VT
# (patrz `selene/src/vt.rs`) — inaczej Ctrl+C na konsoli wysyła SIGINT do całej grupy
# procesów VT, ginie proces `greetd` nadzorujący sesję i logind ją kończy.
# Uwaga: `selene &` w nieinteraktywnej powłoce dostaje stdin=/dev/null, dlatego
# przekazujemy kopię naszego stdin jawnie.
if [ -t 0 ]; then
exec 3<&0
selene 0<&3 &
selene_pid=$!
exec 3<&-
else
selene &
selene_pid=$!
fi
# Czekamy na **marker gotowości** zapisany przez Selene (a nie na plik gniazda, który
# mógł zostać po poprzedniej sesji). Marker zawiera nazwę gniazda, na którym Selene
# naprawdę słucha — dzięki temu działa też `wayland-1`.
sock=""
waited=0
while [ "$waited" -lt 100 ] && [ ! -f "$marker" ]; do
sleep 0.05
waited=$((waited + 1))
done
if [ -f "$marker" ]; then
sock="$(cat "$marker" 2>/dev/null)"
ts "gniazdo Wayland gotowe: ${sock:-?} (po $((waited * 50)) ms)"
else
ts "UWAGA: Selene nie zgłosił gotowości w 5 s — powłoka może się nie połączyć"
fi
# Standardowe integracje toolkitów z Waylandem (Firefox, Qt, GTK, SDL, Electron)
export WAYLAND_DISPLAY="${WAYLAND_DISPLAY:-${sock:-wayland-0}}"
# Aplikacje X11: Selene uruchamia Xwayland i zapisuje numer ekranu w markerze.
# Czekamy krótko (zwykle pojawia się od razu), żeby powłoka — a przez nią aplikacje —
# dostały poprawne `DISPLAY`.
# Aplikacje X11: Selene uruchamia Xwayland i zapisuje numer ekranu w markerze.
# Powłoki **nie blokujemy** czekaniem na X11 — panel ma pojawić się natychmiast.
# Gdy marker już jest, ustawiamy DISPLAY od razu; gdy jeszcze nie, luna-shell odczyta
# go przy starcie każdej aplikacji, a wątek w tle uzupełni środowisko aktywacji D-Bus.
display_marker="$rt/luna-display"
xnum=""
if [ -f "$display_marker" ]; then
xnum="$(cat "$display_marker" 2>/dev/null)"
fi
if [ -n "$xnum" ] && [ -S "/tmp/.X11-unix/X$xnum" ]; then
export DISPLAY=":$xnum"
ts "X11 gotowe: DISPLAY=$DISPLAY"
else
# Bez Xwaylanda **nie zostawiamy odziedziczonego `DISPLAY`** (np. `:0` z pulpitu
# gospodarza) — inaczej aplikacje X11 lądują na tamtym ekranie i widać je
# z obcymi dekoracjami, poza Luną.
unset DISPLAY
ts "X11 jeszcze nie zgłosił ekranu — startuję powłokę od razu"
(
i=0
while [ "$i" -lt 100 ]; do
if [ -f "$display_marker" ]; then
n="$(cat "$display_marker" 2>/dev/null)"
if [ -n "$n" ] && [ -S "/tmp/.X11-unix/X$n" ]; then
if command -v dbus-update-activation-environment >/dev/null 2>&1; then
dbus-update-activation-environment DISPLAY=":$n" 2>/dev/null || true
fi
break
fi
fi
sleep 0.05
i=$((i + 1))
done
) &
fi
# Diagnostyka: jakie ekrany X w ogóle istnieją (pomaga, gdy coś idzie nie tam).
if [ -d /tmp/.X11-unix ]; then
ts "ekrany X w systemie: $(ls /tmp/.X11-unix 2>/dev/null | tr '\n' ' ')"
fi
export MOZ_ENABLE_WAYLAND=1
export QT_QPA_PLATFORM="wayland;xcb"
export GDK_BACKEND="wayland,x11"
export SDL_VIDEODRIVER="wayland"
export CLUTTER_BACKEND="wayland"
export ELECTRON_OZONE_PLATFORM_HINT="auto"
# Java/AWT: nasz XWM nie reparentuje okien (brak ramek X11), więc bez tej zmiennej okna
# aplikacji Javy (IDE, narzędzia AWT/Swing) potrafią się źle rysować albo nie pojawiać.
export _JAVA_AWT_WM_NONREPARENTING=1
# Motyw kursora dla X11/Xwayland. Xwayland bez motywu zgłasza wbudowany
# `X_cursor` („X”) dla okien bez własnego kursora — a tak zachowuje się m.in.
# Zed. Wybieramy pierwszy motyw, który **naprawdę** ma pliki kursorów
# (`Pagan-Cursors` bywa pustym opakowaniem z samym `Inherits`), oraz ustawiamy
# `XCURSOR_PATH`, bo libXcursor domyślnie nie zagląda do /usr/local/share/icons.
if [ -z "${XCURSOR_PATH:-}" ]; then
XCURSOR_PATH="${HOME:-}/.icons:${HOME:-}/.local/share/icons:/usr/local/share/icons:/usr/share/icons:/usr/share/pixmaps"
export XCURSOR_PATH
fi
if [ -z "${XCURSOR_THEME:-}" ]; then
for theme in Luna-Cursors Pagan-Cursors Adwaita DMZ-Black DMZ-White; do
for dir in "${HOME:-}/.icons" "${HOME:-}/.local/share/icons" /usr/local/share/icons /usr/share/icons; do
if [ -d "$dir/$theme/cursors" ] && [ -n "$(ls -A "$dir/$theme/cursors" 2>/dev/null)" ]; then
XCURSOR_THEME="$theme"
break 2
fi
done
done
if [ -n "${XCURSOR_THEME:-}" ]; then
export XCURSOR_THEME
fi
fi
if [ -z "${XCURSOR_SIZE:-}" ]; then
XCURSOR_SIZE=24
export XCURSOR_SIZE
fi
ts "krok: motyw kursora gotowy (${XCURSOR_THEME:-wbudowany})"
# ── Powłoka startuje **natychmiast** ─────────────────────────────────────────
#
# Wszystko, czego potrzebuje panel (gniazdo Waylanda, `DISPLAY`, motyw kursora),
# jest już gotowe. Portale, keyring, polkit i aktualizacja środowiska D-Bus /
# systemd idą **po** powłoce — w tle. Wcześniej blokujące `systemctl --user
# start xdg-desktop-portal` potrafiło zjeść 75 s (limit zadania systemd),
# a panel pojawiał się dopiero po nim.
if command -v luna-security >/dev/null 2>&1; then
# Monitor prywatności: startuje przed panelem, żeby wskaźniki mikrofonu /
# kamery / sieci miały stan od pierwszej klatki.
ts "uruchamiam luna-security"
luna-security daemon >/dev/null 2>&1 &
fi
# Powłoka Luna (panel, launcher, OSD).
#
# Domyślnie **jeden** panel na monitorze głównym (pierwszym) — popupy (kalendarz, Wi‑Fi,
# głośność) są rysowane w tym samym buforze co pasek, więc mają sens tylko na jednym
# ekranie. Panel na każdym monitorze (osobna instancja powłoki na wyjście) włączasz
# jawnie: LUNA_PANELS=all luna-session
if command -v luna-shell >/dev/null 2>&1; then
if [ "${LUNA_PANELS:-primary}" = "all" ]; then
nouts=1
if [ -f "$rt/luna-outputs" ]; then
n="$(cat "$rt/luna-outputs" 2>/dev/null)"
case "$n" in
''|*[!0-9]*) n=1 ;;
esac
if [ "$n" -ge 1 ]; then nouts="$n"; fi
fi
ts "uruchamiam luna-shell x$nouts (panel na każdym monitorze)"
i=0
while [ "$i" -lt "$nouts" ]; do
LUNA_OUTPUT="$i" luna-shell &
i=$((i + 1))
done
else
ts "uruchamiam luna-shell (panel na monitorze głównym)"
luna-shell &
fi
else
ts "brak luna-shell w PATH"
fi
if [ "${t0:-0}" != 0 ] && command -v date >/dev/null 2>&1; then
t1="$(date +%s%3N 2>/dev/null || echo 0)"
if [ "$t1" != 0 ] && [ "$t1" -ge "$t0" ]; then
ts "powłoka uruchomiona po $((t1 - t0)) ms od startu kompozytora"
fi
if [ "${t_session:-0}" != 0 ] && [ "$t1" != 0 ] && [ "$t1" -ge "$t_session" ]; then
ts "sesja gotowa po $((t1 - t_session)) ms od startu skryptu"
fi
fi
# Ikony pulpitu (pliki, foldery, skróty `.desktop`). Osobny proces na każde
# wyjście: powierzchnia warstwowa wiąże się z konkretnym monitorem przez
# `LUNA_OUTPUT`, więc bez tego drugi ekran nie ma ikon, menu PPM ani
# przeciągania. Pozycje ikon są zapisywane per monitor (`pos1:` w `desktop.conf`).
if command -v luna-desktop >/dev/null 2>&1; then
nouts=1
panels=1
if [ -f "$rt/luna-outputs" ]; then
n="$(cat "$rt/luna-outputs" 2>/dev/null)"
case "$n" in
''|*[!0-9]*) n=1 ;;
esac
if [ "$n" -ge 1 ]; then nouts="$n"; fi
fi
if [ "${LUNA_PANELS:-primary}" = "all" ]; then
panels="$nouts"
fi
ts "uruchamiam luna-desktop x$nouts (ikony na każdym monitorze)"
i=0
while [ "$i" -lt "$nouts" ]; do
# Rezerwa na panel tylko tam, gdzie panel naprawdę jest.
if [ "$i" -lt "$panels" ]; then inset=1; else inset=0; fi
LUNA_OUTPUT="$i" LUNA_DESKTOP_INSET="$inset" luna-desktop >/dev/null 2>&1 &
i=$((i + 1))
done
else
ts "brak luna-desktop w PATH"
fi
# Aktualizacja środowiska aktywacji D-Bus i systemd (wymagane m.in. dla xdg-desktop-portal).
#
# **Nie mogą blokować startu powłoki.** `dbus-update-activation-environment --systemd`
# i `systemctl --user` potrafią zawiesić się do limitu systemd (90 s) — a przez ten
# czas widać tylko tapetę rysowaną przez Selene, bez panelu. Każdy krok ma własny
# krótki limit, a start jednostek jest `--no-block`.
tmo=""
if command -v timeout >/dev/null 2>&1; then
tmo="timeout 3"
fi
# Cały blok idzie w tło: powłoka nie może czekać na D-Bus/systemd nawet wtedy,
# gdy menedżer użytkownika dopiero wstaje (D-Bus ma 25 s limitu, a dwa oczekiwania
# dawały 50 s samej tapety przed pierwszym panelem).
(
if command -v dbus-update-activation-environment >/dev/null 2>&1; then
$tmo dbus-update-activation-environment --systemd LANGUAGE LANG LC_TIME TZ WAYLAND_DISPLAY DISPLAY XDG_CURRENT_DESKTOP XDG_SESSION_TYPE XDG_SESSION_DESKTOP MOZ_ENABLE_WAYLAND QT_QPA_PLATFORM GDK_BACKEND XCURSOR_THEME XCURSOR_SIZE XCURSOR_PATH _JAVA_AWT_WM_NONREPARENTING 2>/dev/null || true
fi
ts "krok: środowisko dbus"
if command -v systemctl >/dev/null 2>&1; then
$tmo systemctl --user import-environment LANGUAGE LANG LC_TIME TZ WAYLAND_DISPLAY DISPLAY XDG_CURRENT_DESKTOP XDG_SESSION_TYPE XDG_SESSION_DESKTOP MOZ_ENABLE_WAYLAND QT_QPA_PLATFORM GDK_BACKEND XCURSOR_THEME XCURSOR_SIZE XCURSOR_PATH _JAVA_AWT_WM_NONREPARENTING 2>/dev/null || true
ts "krok: środowisko systemd"
# `graphical-session.target` ma `RefuseManualStart=yes` — wciągamy go
# zależnością z własnego targetu. Usługi portali
# (`Requisite=graphical-session.target`) bez tego nie startują przez D-Bus.
$tmo systemctl --user start --no-block luna-session.target >/dev/null 2>&1 || true
ts "krok: target sesji uruchomiony"
fi
) &
ts "krok: dbus/systemd w tle"
# Portal XDG (aplikacje GTK4/flatpak/Steam): startujemy jawnie, z poprawnym
# środowiskiem sesji. Bez tego aktywacja D-Bus bywała bez WAYLAND_DISPLAY /
# XDG_CURRENT_DESKTOP, a aplikacje czekały ~25 s na odpowiedź („Cannot get portal …
# Przekroczono czas oczekiwania”).
#
# Frontend `xdg-desktop-portal` sam nic nie robi — każde żądanie kieruje do backendu
# wybranego przez `luna-portals.conf`:
# * `gtk` — FileChooser, Settings, Notification, Print, Access, …
# * `wlr` — ScreenCast i Screenshot (Selene implementuje `wlr-screencopy`).
# Backendy sprawdzamy **osobno**. Wcześniej brak jednej biblioteki GTK wyłączał
# cały portal, więc nawet poprawny backend wlr nie mógł udostępnić ekranu.
portal_bin=""
for p in /usr/libexec/xdg-desktop-portal /usr/lib/xdg-desktop-portal; do
if [ -x "$p" ]; then portal_bin="$p"; break; fi
done
# Wynik: `ok`, `uszkodzony` (brakuje bibliotek) albo `brak`.
portal_gtk=brak
portal_gtk_missing=""
for backend in /usr/libexec/xdg-desktop-portal-gtk /usr/lib/xdg-desktop-portal-gtk; do
[ -x "$backend" ] || continue
portal_gtk=ok
if command -v ldd >/dev/null 2>&1; then
portal_gtk_missing="$($tmo ldd "$backend" 2>/dev/null | sed -n 's/^[[:space:]]*\([^[:space:]]*\) => not found.*/\1/p' | tr '\n' ' ')"
[ -n "$portal_gtk_missing" ] && portal_gtk=uszkodzony
fi
break
done
portal_wlr=brak
portal_wlr_missing=""
for backend in /usr/libexec/xdg-desktop-portal-wlr /usr/lib/xdg-desktop-portal-wlr; do
[ -x "$backend" ] || continue
portal_wlr=ok
if command -v ldd >/dev/null 2>&1; then
portal_wlr_missing="$($tmo ldd "$backend" 2>/dev/null | sed -n 's/^[[:space:]]*\([^[:space:]]*\) => not found.*/\1/p' | tr '\n' ' ')"
[ -n "$portal_wlr_missing" ] && portal_wlr=uszkodzony
fi
break
done
ts "krok: backendy portali sprawdzone (gtk=$portal_gtk wlr=$portal_wlr)"
case "$portal_gtk" in
uszkodzony)
ts "portal/gtk: uszkodzony backend (brak: $portal_gtk_missing)"
ts " → okna wyboru plików/Ustawienia pójdą przez inny backend albo bez portalu"
;;
brak)
ts "portal/gtk: brak pakietu xdg-desktop-portal-gtk"
;;
esac
case "$portal_wlr" in
uszkodzony)
ts "portal/wlr: uszkodzony backend (brak: $portal_wlr_missing) — ScreenCast nie zadziała"
;;
brak)
ts "portal/wlr: brak xdg-desktop-portal-wlr — udostępnianie ekranu (OBS, Discord, Meet) nie zadziała"
ts " sudo pag install xdg-desktop-portal-wlr"
;;
esac
# Mapowanie ScreenCast → wlr. Starsze wydania pakietu Luny dostarczały
# `luna-portals.conf` tylko z `default=gtk`, więc mimo zainstalowanego backendu
# wlr każde udostępnienie ekranu kończyło się błędem. Dopisujemy mapowanie
# wyłącznie w configu użytkownika i tylko wtedy, gdy systemowy plik go nie ma;
# gdy pakiet zostanie zaktualizowany, nasz plik zniknie sam.
portal_conf=/usr/share/xdg-desktop-portal/luna-portals.conf
portal_conf_ok=0
portal_conf_generated=0
if [ -r "$portal_conf" ] && grep -q 'ScreenCast=wlr' "$portal_conf"; then
portal_conf_ok=1
fi
user_portal_dir="${XDG_CONFIG_HOME:-$HOME/.config}/xdg-desktop-portal"
user_portal_conf="$user_portal_dir/luna-portals.conf"
if [ "$portal_conf_ok" = 1 ]; then
if [ -r "$user_portal_conf" ] && grep -q 'wygenerowane przez luna-session' "$user_portal_conf"; then
rm -f "$user_portal_conf" 2>/dev/null || true
fi
elif [ "$portal_wlr" = ok ]; then
if [ ! -e "$user_portal_conf" ]; then
mkdir -p "$user_portal_dir" 2>/dev/null || true
cat >"$user_portal_conf" <<'PORTAL_CONF'
# wygenerowane przez luna-session — pakiet nie dostarczył mapowania ScreenCast
[preferred]
default=gtk;
org.freedesktop.impl.portal.ScreenCast=wlr;
org.freedesktop.impl.portal.Screenshot=wlr;
PORTAL_CONF
ts "uzupełniam $user_portal_conf (stary luna-portals.conf bez ScreenCast=wlr)"
portal_conf_generated=1
fi
fi
portal_log="${log_dir:-${XDG_STATE_HOME:-$HOME/.local/state}/luna}/portal.log"
# Decyzja o środowisku dla aplikacji GTK zapada **synchronicznie** (jest tania),
# bo `GTK_USE_PORTAL` / `GDK_DEBUG` muszą odziedziczyć wszystkie późniejsze
# aplikacje. Sam start usług idzie już w tle.
if [ -z "$portal_bin" ]; then
ts "xdg-desktop-portal: brak frontendu — aplikacje użyją własnych okien"
export GTK_USE_PORTAL=0
elif [ "$portal_gtk" != ok ]; then
if [ "$portal_wlr" != ok ]; then
ts "xdg-desktop-portal: żaden backend nie jest kompletny — pomijam portal"
ts " Flatpak/Steam bez portalu nie uruchomi gier (timeout org.freedesktop.portal.Flatpak)"
else
# Backend GTK uszkodzony, ale wlr działa: nie każmy aplikacjom GTK czekać
# na portal, który i tak nie obsłuży wyboru pliku.
ts "portal/gtk: pomijam w aplikacjach GTK (GTK_USE_PORTAL=0)"
fi
export GTK_USE_PORTAL=0
fi
if [ "${GTK_USE_PORTAL:-}" = 0 ]; then
if [ -n "${GDK_DEBUG:-}" ]; then
export GDK_DEBUG="$GDK_DEBUG,no-portals"
else
export GDK_DEBUG="no-portals"
fi
fi
# Start portalu i backendów **w tle**.
#
# `systemctl --user start` bez `--no-block` czeka na zakończenie zadania — przy
# wolno wstającym menedżerze użytkownika to 75 s (limit systemd). Powłoka
# startowała wtedy dopiero po portalu, czyli po ponad minucie tapety.
if [ -n "$portal_bin" ] && { [ "$portal_gtk" = ok ] || [ "$portal_wlr" = ok ]; }; then
(
portal_started=0
# Preferujemy usługę systemd: ma własny cgroup i nie zostawia sieroty po sesji.
if command -v systemctl >/dev/null 2>&1; then
if $tmo systemctl --user start --no-block xdg-desktop-portal.service >>"$portal_log" 2>&1; then
portal_started=1
fi
fi
if [ "$portal_started" = 0 ]; then
"$portal_bin" >>"$portal_log" 2>&1 &
fi
ts "uruchamiam xdg-desktop-portal (gtk=$portal_gtk wlr=$portal_wlr, log: $portal_log)"
# Backendy startujemy jawnie — usługa aktywowana przez D-Bus dostaje środowisko
# z chwili aktywacji, a nie z chwili startu sesji (np. po restarcie D-Busa).
if command -v systemctl >/dev/null 2>&1; then
if [ "$portal_gtk" = ok ]; then
$tmo systemctl --user start --no-block xdg-desktop-portal-gtk.service >>"$portal_log" 2>&1 || true
fi
if [ "$portal_wlr" = ok ]; then
if ! $tmo systemctl --user start --no-block xdg-desktop-portal-wlr.service >>"$portal_log" 2>&1; then
ts "portal/wlr: usługa nie wystartowała — sprawdź log: $portal_log"
fi
fi
# Frontend cache'uje `luna-portals.conf` przy starcie — po wygenerowaniu
# brakującego mapowania trzeba go przeładować, inaczej ScreenCast nadal
# trafiałby do backendu GTK.
if [ "$portal_conf_generated" = 1 ]; then
$tmo systemctl --user restart --no-block xdg-desktop-portal.service >>"$portal_log" 2>&1 || true
fi
fi
# Dowód, że frontend i backend GTK naprawdę odpowiadają. Bez tego usterka
# portalu ujawnia się dopiero po 25 s w aplikacji (jak w RapidRAW).
# `Settings.Read` obsługuje backend GTK — przy jego braku test nie ma sensu.
if [ "$portal_gtk" != ok ]; then
ts "portal/Settings: backend gtk niedostępny — pomijam test Settings.Read"
elif command -v gdbus >/dev/null 2>&1 && command -v timeout >/dev/null 2>&1; then
# Start jest nieblokujący, więc frontend potrzebuje kilku prób.
portal_reply=""
tries=0
while [ "$tries" -lt 6 ] && [ -z "$portal_reply" ]; do
portal_reply="$(timeout 2 gdbus call --session \
--dest org.freedesktop.portal.Desktop \
--object-path /org/freedesktop/portal/desktop \
--method org.freedesktop.portal.Settings.Read \
org.freedesktop.appearance color-scheme 2>/dev/null || true)"
tries=$((tries + 1))
if [ -z "$portal_reply" ] && [ "$tries" -lt 6 ]; then
sleep 0.5
fi
done
if [ -n "$portal_reply" ]; then
ts "portal odpowiada (Settings.Read: $portal_reply)"
else
ts "UWAGA: portal nie odpowiedział — sprawdź $portal_log"
fi
fi
) &
ts "krok: portal startuje w tle"
fi
# Aplikacje uruchamiane przez D-Bus (zsynchronizuj też środowisko aktywacji).
if command -v dbus-update-activation-environment >/dev/null 2>&1; then
$tmo dbus-update-activation-environment \
${GTK_USE_PORTAL:+GTK_USE_PORTAL} ${GDK_DEBUG:+GDK_DEBUG} 2>/dev/null || true
fi
# Baza kluczy i haseł (Luna Keyring — Secret Service API)
rm -f "$rt/luna-keyring-ready" 2>/dev/null || true
if command -v luna-keyring >/dev/null 2>&1; then
ts "uruchamiam luna-keyring"
luna-keyring &
# Korektor (PipeWire + LADSPA): jeśli użytkownik włączył go w ustawieniach,
# łańcuch filtrów wstaje razem z sesją. `luna-eq start` nic nie robi, gdy
# korektor jest wyłączony; błędy trafiają do ~/.cache/luna/equalizer.log.
if command -v luna-eq >/dev/null 2>&1; then
( luna-eq start >/dev/null 2>&1 || true ) &
fi
# Krótkie oczekiwanie na zajęcie nazwy `org.freedesktop.secrets`. Aplikacje
# uruchamiane zaraz po zalogowaniu (Zed, VS Code) inaczej nie widzą keyringu.
k=0
while [ "$k" -lt 40 ] && [ ! -f "$rt/luna-keyring-ready" ]; do
sleep 0.05
k=$((k + 1))
done
if [ -f "$rt/luna-keyring-ready" ]; then
ts "luna-keyring gotowy (po $((k * 50)) ms)"
else
ts "luna-keyring: brak potwierdzenia gotowości po 2 s"
fi
fi
# Agent uwierzytelniania Polkit (okienka autoryzacji uprawnień)
if command -v luna-polkit >/dev/null 2>&1; then
ts "uruchamiam luna-polkit"
luna-polkit &
else
for agent in \
/usr/lib/polkit-gnome/polkit-gnome-authentication-agent-1 \
/usr/libexec/polkit-gnome-authentication-agent-1 \
/usr/lib/policykit-1-gnome/polkit-gnome-authentication-agent-1 \
lxpolkit
do
if command -v "$agent" >/dev/null 2>&1 || [ -x "$agent" ]; then
"$agent" &
break
fi
done
fi
# Powitanie: „Co nowego” i (na obrazie live) skrót do instalatora.
#
# Okno pokazuje się przy każdym logowaniu, chyba że użytkownik zaznaczył
# w nim „Nie uruchamiaj ponownie po zalogowaniu”. Wtedy w `welcome.conf`
# leży `autostart = false` i ten blok je pomija. Plik można usunąć, żeby
# przywrócić powitanie.
if command -v luna-welcome >/dev/null 2>&1; then
welcome_conf=""
if [ -n "${XDG_CONFIG_HOME:-}" ]; then
welcome_conf="$XDG_CONFIG_HOME/luna/welcome.conf"
elif [ -n "${HOME:-}" ]; then
welcome_conf="$HOME/.config/luna/welcome.conf"
fi
if [ -n "$welcome_conf" ] && [ -r "$welcome_conf" ] \
&& grep -qiE '^[[:space:]]*autostart[[:space:]]*=[[:space:]]*(0|false|no|off)[[:space:]]*$' "$welcome_conf"; then
ts "powitanie wyłączone przez użytkownika ($welcome_conf)"
else
ts "uruchamiam luna-welcome"
luna-welcome >/dev/null 2>&1 &
fi
else
ts "brak luna-welcome w PATH"
fi
# Sesja żyje, dopóki działa kompozytor.
status=0
wait "$selene_pid" || status=$?
ts "selene zakończył się (status $status) — kończę sesję"
exit "$status"