PaganOS Luna 0.6.0
PL EN DE
← pagan-welcome

Commit 36e6c1e

8
files
+713
added
-358
deleted
@@ -20,7 +20,7 @@ CFLAGS += $(shell $(PKG_CONFIG) --cflags $(PKGS))
20 20 # LDFLAGS podawane z zewnątrz (np. rpath-link do bibliotek rootfs).
21 21 LDFLAGS ?=
22 22
23 -LIBS := $(shell $(PKG_CONFIG) --libs $(PKGS))
23 +LIBS := $(shell $(PKG_CONFIG) --libs $(PKGS)) -lutil
24 24
25 25 PREFIX ?= /usr
26 26 BINDIR = $(PREFIX)/bin
@@ -13,14 +13,16 @@ prezentacją.
13 13
14 14 | Sekcja | Co robi |
15 15 | --- | --- |
16 -| **Nowości** | Pobiera informacje o wydaniach z <https://docs.paganlinux.eu/docs/paganlinux> i pokazuje je jako listę zmian. Działa też offline (ostatnia pobrana wersja z pamięci podręcznej). |
16 +| **Nowości** | Pobiera informacje o wydaniach z <https://docs.paganlinux.eu/docs/paganlinux> i pokazuje je jako listę zmian. Treść zmienia się razem z językiem interfejsu (backend wysyła nagłówek `Accept-Language`). Działa też offline (ostatnia pobrana wersja z pamięci podręcznej). |
17 17 | **Instalator** | Uruchamia instalator Calamares – aktywny wyłącznie w sesji live (z pendrive'a/ISO). |
18 -| **Aktualizacja** | `pag update` + `pag upgrade` (system rolling). Dodatkowo przycisk uruchamiający aktualizację w oknie terminala. |
19 -| **Sklep** | Przeglądanie i wyszukiwanie pakietów z repozytorium PAG oraz instalacja/usuwanie przez `pag`. |
20 -| **Ustawienia** | Język, układ klawiatury, strefa czasowa, nazwa komputera, połączenie Wi-Fi. |
18 +| **Aktualizacja** | `pag update` + `pag upgrade` (system rolling) uruchamiane **we wbudowanym terminalu** (pseudotty). Widać pełny przebieg, można wpisać odpowiedź dla `pag` i przerwać przyciskiem **Przerwij**. |
19 +| **Sklep** | Przeglądanie i wyszukiwanie pakietów z repozytorium PAG. Dla niezainstalowanych – **Zainstaluj**; dla zainstalowanych – **Usuń**, a gdy pakiet ma aplikację graficzną – dodatkowo **Otwórz**. |
20 +
21 +Wi-Fi (**pagan-wifi**) uruchamiane z przycisku w nagłówku okna (oraz z apletu tray).
21 22
22 23 Interfejs jest **dwujęzyczny (PL/EN)**. Język wybiera się w nagłówku i jest
23 -zapamiętywany w `~/.config/pagan-welcome/config.ini`.
24 +zapamiętywany w `~/.config/pagan-welcome/config.ini`. Gdy język jest
25 +nieustawiony, domyślnie używany jest **angielski**.
24 26
25 27 ## Tryby uruchomienia
26 28
@@ -50,21 +52,21 @@ Pole wyboru w nagłówku zapisuje `show_on_login=false` w konfiguracji. Aplet
50 52 nadal działa w tle – ukrywane jest tylko okno główne. Aby je przywrócić,
51 53 odznacz pole (albo ustaw `show_on_login=true`).
52 54
53 -## Aktualizacja: aplikacja czy terminal?
55 +## Aktualizacja we wbudowanym terminalu
54 56
55 -`pag` pyta o potwierdzenie przed operacją (`_ask_confirm`). Bez terminala
56 -brak odpowiedzi na `input()` daje `EOFError`, dlatego **domyślnie anuluje**
57 -operację. Z tego powodu aplikacja:
57 +Aktualizacja nie musi już otwierać zewnętrznego emulatora terminala. `pag`
58 +uruchamiany jest pod **pseudottty** (PTY) wbudowanym w aplikację, dzięki czemu:
58 59
59 -* uruchamia `pag` z `PAG_YES=1` (potwierdzenie automatyczne) i bez TTY
60 - (kolory i interaktywne paski postępu są wtedy wyłączone – `pag` sam to
61 - wykrywa), a wyjście strumieniuje na bieżąco do pola logu;
62 -* oferuje osobny przycisk **„Aktualizuj w terminalu”**, który otwiera
63 - `sudo pagan-update` w emulatorze terminala – dla użytkowników, którzy chcą
64 - widzieć pełny, kolorowy przebieg i mieć możliwość reakcji.
60 +* `pag` widzi prawdziwy terminal – nie „zawiesza się” na braku wejścia i nie
61 + blokuje menedżera pakietów;
62 +* przebieg widać na żywo (kolory ANSI są czyszczone, a strumień obsługuje
63 + końce linii tty);
64 +* pole **Odpowiedź** pozwala wpisać tekst, gdyby `pag` o coś spytał;
65 +* przycisk **Przerwij** kończy proces (SIGTERM na całą grupę).
65 66
66 -Dzięki temu zwykła aktualizacja jest wygodna (integracja w oknie), a wariant
67 -terminalowy pozostaje dostępny, gdy jest potrzebny.
67 +`pag` uruchamiany jest z `PAG_YES=1` (potwierdzenie automatyczne). Gdy trzeba
68 +hasła roota, aplikacja pyta o nie i podaje je na wejście procesu **bez echa**
69 +(echo na PTY jest wyłączane na czas podania hasła).
68 70
69 71 ## Uprawnienia
70 72
@@ -104,6 +106,7 @@ pagan-welcome-backend news pl # UPDATED/CACHED/TITLE/REL/NOTE
104 106 pagan-welcome-backend repo # PKG: nazwa, wersja, rozmiar, opis, zależności, licencja
105 107 pagan-welcome-backend installed # INST: nazwa, wersja
106 108 pagan-welcome-backend updates # UPDATES: liczba
109 +pagan-welcome-backend pkgfiles <pakiet> # GUI 1/0 + DESKTOP: nazwa, Exec
107 110 pagan-welcome-backend sysinfo # LOCALE/KEYMAP/TIMEZONE/HOSTNAME/LIVE/CALAMARES/PAG
108 111 pagan-welcome-backend timezones # TZ: lista stref
109 112 ```
@@ -121,10 +124,11 @@ nie pokaże surowego identyfikatora.
121 124
122 125 ## Tłumaczenia treści nowości
123 126
124 -Treść nowości pochodzi ze strony dokumentacji i zależy od tego, jakie wersje
125 -językowe udostępnia serwer. Serwer (patrz `blueprints/docs.py`) przekierowuje
126 -na istniejącą wersję językową, więc gdy danego dokumentu nie ma po angielsku,
127 -wyświetlona zostanie wersja polska – to zachowanie serwera, nie aplikacji.
127 +Treść nowości pochodzi ze strony dokumentacji. Język wybiera backend, wysyłając
128 +nagłówek `Accept-Language` (`pl`/`en`) – serwer (`blueprints/docs.py`,
129 +`get_lang()`) rozpoznaje go i zwraca wersję językową dokumentu. Gdy danej wersji
130 +brak, serwer zwraca dostępną (fallback) – to zachowanie serwera. Dzięki temu
131 +zmiana języka w nagłówku przeładowuje także treść pobieraną z sieci.
128 132
129 133 ## Licencja
130 134
@@ -11,6 +11,7 @@ Uruchomiony z argumentem działa też jako CLI dla aplikacji GTK
11 11 pagan-welcome-backend.py repo
12 12 pagan-welcome-backend.py installed
13 13 pagan-welcome-backend.py updates
14 + pagan-welcome-backend.py pkgfiles <pakiet>
14 15 pagan-welcome-backend.py sysinfo
15 16 pagan-welcome-backend.py timezones
16 17
@@ -77,7 +78,7 @@ def save_config(cfg):
77 78
78 79
79 80 def detect_lang(cfg=None):
80 - """Ustal język: konfiguracja → $LANG → polski."""
81 + """Ustal język: konfiguracja → $LANG → angielski (domyślny)."""
81 82 cfg = cfg if cfg is not None else load_config()
82 83 lang = (cfg.get("lang") or "").strip().lower()
83 84 if lang in ("pl", "en"):
@@ -87,7 +88,7 @@ def detect_lang(cfg=None):
87 88 return "pl"
88 89 if env.lower().startswith("en"):
89 90 return "en"
90 - return "pl"
91 + return "en"
91 92
92 93
93 94 # ── Wykrywanie środowiska ─────────────────────────────────────────────────
@@ -153,17 +154,21 @@ HTTP_RETRIES = 3 # łącznie próby (pierwsza + ponowienia)
153 154 HTTP_RETRY_DELAY = 3.0 # sekundy przerwy między próbami
154 155
155 156
156 -def http_get(url, timeout=HTTP_TIMEOUT, retries=HTTP_RETRIES):
157 +def http_get(url, timeout=HTTP_TIMEOUT, retries=HTTP_RETRIES, headers=None):
157 158 """Pobierz URL i zwróć treść jako tekst (UTF-8).
158 159
159 160 Błąd HTTP (4xx/5xx) NIE jest ponawiany – to nie usterka sieci. Ponawiamy
160 161 tylko błędy przejściowe (brak trasy, DNS, przekroczony czas). Rzuca OSError.
162 + `headers` pozwala dodać własne nagłówki (np. Accept-Language).
161 163 """
162 164 attempts = max(1, int(retries))
163 165 last = None
166 + hdrs = {"User-Agent": USER_AGENT}
167 + if headers:
168 + hdrs.update(headers)
164 169 for attempt in range(attempts):
165 170 try:
166 - req = urllib.request.Request(url, headers={"User-Agent": USER_AGENT})
171 + req = urllib.request.Request(url, headers=hdrs)
167 172 with urllib.request.urlopen(req, timeout=timeout) as resp:
168 173 raw = resp.read()
169 174 return raw.decode("utf-8", errors="replace")
@@ -309,7 +314,7 @@ def _read_cache(name):
309 314 return None
310 315
311 316
312 -def fetch_news(lang="pl", force=False):
317 +def fetch_news(lang="en", force=False):
313 318 """Pobierz nowości dla języka `lang`.
314 319
315 320 Zwraca dict: {title, releases, source, updated, cached, error}.
@@ -334,7 +339,10 @@ def fetch_news(lang="pl", force=False):
334 339 return result
335 340
336 341 try:
337 - html = http_get(url)
342 + # Język treści serwer dokumentacji rozpoznaje po nagłówku Accept-Language
343 + # (get_lang(): cookie → Accept-Language → en). Bez niego zawsze wracał
344 + # angielski, więc zmiana języka w aplikacji nie zmieniała treści.
345 + html = http_get(url, headers={"Accept-Language": lang})
338 346 parsed = parse_news_html(html)
339 347 result["title"] = parsed["title"]
340 348 result["releases"] = parsed["releases"]
@@ -419,6 +427,51 @@ def world_packages():
419 427 return set()
420 428
421 429
430 +# Kody pól w linii Exec= pliku .desktop (rozwinie je launcher – my je usuwamy).
431 +_DESKTOP_FIELD_CODES = ("%f", "%F", "%u", "%U", "%i", "%c", "%k", "%d",
432 + "%D", "%n", "%N", "%v", "%m", "%%")
433 +
434 +
435 +def clean_exec(exec_line):
436 + """Usuń z linii Exec= kody pól .desktop i znormalizuj spacje."""
437 + text = exec_line
438 + for code in _DESKTOP_FIELD_CODES:
439 + text = text.replace(code, "")
440 + return re.sub(r"\s+", " ", text).strip()
441 +
442 +
443 +def package_desktops(name):
444 + """Zwróć listę poleceń Exec aplikacji graficznych pakietu (`pag files`).
445 +
446 + Pusta lista = pakiet bez pliku .desktop (brak wersji graficznej). Sluży do
447 + przycisku „Otwórz” w sklepie i odróżnienia GUI od narzędzi konsolowych.
448 + """
449 + if not valid_package_name(name):
450 + return []
451 + out = _run_capture([pag_cmd(), "files", name], timeout=20)
452 + if not out:
453 + return []
454 + execs = []
455 + for line in out.splitlines():
456 + path = line.strip()
457 + if not path.startswith("/") or not path.endswith(".desktop"):
458 + continue
459 + if not os.path.isfile(path):
460 + continue
461 + try:
462 + with open(path, encoding="utf-8", errors="replace") as fh:
463 + for dline in fh:
464 + dline = dline.strip()
465 + if dline.startswith("Exec="):
466 + cmd = clean_exec(dline[5:])
467 + if cmd:
468 + execs.append(cmd)
469 + break
470 + except OSError:
471 + continue
472 + return execs
473 +
474 +
422 475 def valid_package_name(name):
423 476 return bool(name) and bool(PKG_NAME_RE.match(name))
424 477
@@ -644,7 +697,7 @@ def _emit(*cols):
644 697
645 698
646 699 def _cmd_news(args):
647 - lang = args[0] if args else "pl"
700 + lang = args[0] if args else "en"
648 701 data = fetch_news(lang, force=True)
649 702 _emit("UPDATED", data.get("updated") or "")
650 703 _emit("CACHED", "1" if data.get("cached") else "0")
@@ -684,6 +737,16 @@ def _cmd_updates(_args):
684 737 return 0
685 738
686 739
740 +def _cmd_pkgfiles(args):
741 + """Info o wersji graficznej pakietu: GUI 1/0 + linie DESKTOP z Exec."""
742 + name = args[0] if args else ""
743 + execs = package_desktops(name)
744 + _emit("GUI", "1" if execs else "0")
745 + for cmd in execs:
746 + _emit("DESKTOP", name, cmd)
747 + return 0
748 +
749 +
687 750 def _cmd_sysinfo(_args):
688 751 _emit("LOCALE", current_locale())
689 752 _emit("KEYMAP", current_keymap())
@@ -704,7 +767,7 @@ def _cmd_timezones(_args):
704 767 def main(argv):
705 768 if not argv or argv[0] in ("-h", "--help", "help"):
706 769 print("Użycie: pagan-welcome-backend.py {news <pl|en>|repo|installed|"
707 - "updates|sysinfo|timezones}")
770 + "updates|pkgfiles <pkg>|sysinfo|timezones}")
708 771 return 0 if argv else 2
709 772 cmd = argv[0]
710 773 args = argv[1:]
@@ -713,6 +776,7 @@ def main(argv):
713 776 "repo": _cmd_repo,
714 777 "installed": _cmd_installed,
715 778 "updates": _cmd_updates,
779 + "pkgfiles": _cmd_pkgfiles,
716 780 "sysinfo": _cmd_sysinfo,
717 781 "timezones": _cmd_timezones,
718 782 }
@@ -23,21 +23,25 @@
23 23
24 24 #include <gtk/gtk.h>
25 25 #include <libnotify/notify.h>
26 +#include <fcntl.h>
26 27 #include <stdlib.h>
27 28 #include <string.h>
29 +#include <unistd.h>
28 30
29 31 #include "pw-i18n.h"
30 32 #include "pw-util.h"
31 33
32 -#define PW_VERSION "1.0"
34 +#define PW_VERSION "1.1"
33 35 #define PW_CALAMARES "/usr/bin/calamares"
34 36 #define PW_TRAY_INTERVAL_SEC (6 * 60 * 60) /* sprawdzanie co 6 godzin */
35 37
36 38 /* ── Stan aplikacji ──────────────────────────────────────────────────────── */
39 +typedef enum { TR_LABEL, TR_BUTTON, TR_PLACEHOLDER } TrKind;
40 +
37 41 typedef struct {
38 42 GtkWidget *widget;
39 43 char *key;
40 - gboolean is_label;
44 + TrKind kind;
41 45 } TrEntry;
42 46
43 47 typedef struct {
@@ -77,9 +81,11 @@ typedef struct {
77 81 GtkWidget *update_result;
78 82 GtkWidget *update_check_btn;
79 83 GtkWidget *update_btn;
80 - GtkWidget *update_terminal_btn;
84 + GtkWidget *update_cancel_btn;
85 + GtkWidget *update_input;
81 86 GtkWidget *update_log;
82 87 gboolean update_busy;
88 + PwPty *update_pty; /* bieżący proces terminala aktualizacji */
83 89
84 90 /* Sklep */
85 91 GtkWidget *store_search;
@@ -90,6 +96,7 @@ typedef struct {
90 96 GtkWidget *store_details;
91 97 GtkWidget *store_install_btn;
92 98 GtkWidget *store_remove_btn;
99 + GtkWidget *store_open_btn;
93 100 GtkWidget *store_log;
94 101 GtkTreeViewColumn *store_col_name;
95 102 GtkTreeViewColumn *store_col_version;
@@ -97,16 +104,15 @@ typedef struct {
97 104 GtkTreeViewColumn *store_col_desc;
98 105 GHashTable *packages; /* name -> Package* */
99 106 GHashTable *installed; /* name -> char* version */
107 + /* name -> czysty Exec z pliku .desktop ("" = brak wersji graficznej).
108 + * Brak wpisu = jeszcze nie sprawdzano. */
109 + GHashTable *gui_cache;
100 110 char *store_selected;
111 + char *store_open_exec; /* Exec aktualnie wybranego pakietu (jeśli GUI) */
112 + PwPty *store_pty; /* bieżący proces instalacji/usuwania w terminalu */
101 113
102 - /* Ustawienia */
103 - GtkWidget *set_lang_combo;
104 - GtkWidget *set_keymap_combo;
105 - GtkWidget *set_tz_combo;
106 - GtkWidget *set_host_entry;
107 - GtkWidget *set_status;
108 - GtkWidget *set_apply_btn;
109 - GtkWidget *set_wifi_btn;
114 + /* Nagłówek */
115 + GtkWidget *header_wifi_btn;
110 116
111 117 /* Aplet tray */
112 118 gboolean tray_mode;
@@ -130,15 +136,27 @@ enum {
130 136
131 137 /* ── Rejestr tłumaczeń ───────────────────────────────────────────────────── */
132 138 static void
133 -tr_register(App *app, GtkWidget *w, const char *key, gboolean is_label)
139 +tr_register_kind(App *app, GtkWidget *w, const char *key, TrKind kind)
134 140 {
135 141 TrEntry *e = g_new0(TrEntry, 1);
136 142 e->widget = w;
137 143 e->key = g_strdup(key);
138 - e->is_label = is_label;
144 + e->kind = kind;
139 145 app->tr_entries = g_list_append(app->tr_entries, e);
140 146 }
141 147
148 +static void
149 +tr_register(App *app, GtkWidget *w, const char *key, gboolean is_label)
150 +{
151 + tr_register_kind(app, w, key, is_label ? TR_LABEL : TR_BUTTON);
152 +}
153 +
154 +static void
155 +tr_register_placeholder(App *app, GtkWidget *w, const char *key)
156 +{
157 + tr_register_kind(app, w, key, TR_PLACEHOLDER);
158 +}
159 +
142 160 static void
143 161 retranslate(App *app)
144 162 {
@@ -146,10 +164,17 @@ retranslate(App *app)
146 164 return;
147 165 for (GList *l = app->tr_entries; l; l = l->next) {
148 166 TrEntry *e = l->data;
149 - if (e->is_label)
167 + switch (e->kind) {
168 + case TR_LABEL:
150 169 gtk_label_set_text(GTK_LABEL(e->widget), pw_tr(e->key));
151 - else
170 + break;
171 + case TR_BUTTON:
152 172 gtk_button_set_label(GTK_BUTTON(e->widget), pw_tr(e->key));
173 + break;
174 + case TR_PLACEHOLDER:
175 + gtk_entry_set_placeholder_text(GTK_ENTRY(e->widget), pw_tr(e->key));
176 + break;
177 + }
153 178 }
154 179 gtk_window_set_title(GTK_WINDOW(app->window), pw_tr("app_title"));
155 180 gtk_label_set_text(GTK_LABEL(app->header_title), pw_tr("app_title"));
@@ -165,7 +190,7 @@ retranslate(App *app)
165 190 pw_tr("store_col_desc"));
166 191 if (app->tray_menu) {
167 192 static const char *keys[] = {"tray_check", "tray_update", "tray_open",
168 - "tray_settings", "tray_quit"};
193 + "tray_wifi", "tray_quit"};
169 194 for (int i = 0; i < 5; i++)
170 195 if (app->tray_items[i])
171 196 gtk_menu_item_set_label(GTK_MENU_ITEM(app->tray_items[i]),
@@ -457,6 +482,18 @@ update_set_busy(App *app, gboolean busy)
457 482 app->update_busy = busy;
458 483 gtk_widget_set_sensitive(app->update_check_btn, !busy);
459 484 gtk_widget_set_sensitive(app->update_btn, !busy);
485 + gtk_widget_set_sensitive(app->update_cancel_btn, busy);
486 + gtk_widget_set_sensitive(app->update_input, busy);
487 +}
488 +
489 +/* Zwolnij uchwyt terminala aktualizacji (jeśli jakiś jest). */
490 +static void
491 +update_release_pty(App *app)
492 +{
493 + if (app->update_pty) {
494 + pw_pty_free(app->update_pty);
495 + app->update_pty = NULL;
496 + }
460 497 }
461 498
462 499 static void
@@ -492,12 +529,16 @@ ask_password(App *app)
492 529 return pw;
493 530 }
494 531
495 -/* Uruchom polecenie z uprawnieniami; pyta o hasło, jeśli trzeba (sudo -S). */
496 -static void
497 -run_privileged(App *app, const char *const cmd[], PwLineFunc on_line,
498 - PwDoneFunc on_done, gpointer data)
532 +/* Uruchom polecenie z uprawnieniami w pseudo-terminalu. Dzięki TTY `pag` działa
533 + * jak w prawdziwym terminalu: nie „zawiesza się” na braku wejścia, pokazuje
534 + * normalny przebieg, a użytkownik może wpisać odpowiedź i przerwać proces.
535 + * Zwraca uchwyt terminala (lub NULL; wtedy on_done już zostało wywołane). */
536 +static PwPty *
537 +run_privileged_pty(App *app, const char *const cmd[], PwLineFunc on_line,
538 + PwDoneFunc on_done, gpointer data)
499 539 {
500 540 char **argv = pw_privileged_argv(cmd);
541 + char *pre = NULL;
501 542 if (pw_privileged_needs_password()) {
502 543 char *pw = ask_password(app);
503 544 if (!pw) {
@@ -506,16 +547,22 @@ run_privileged(App *app, const char *const cmd[], PwLineFunc on_line,
506 547 if (on_done)
507 548 on_done(130, data);
508 549 g_strfreev(argv);
509 - return;
550 + return NULL;
510 551 }
511 - char *input = g_strconcat(pw, "\n", NULL);
512 - pw_spawn((const char *const *) argv, input, on_line, on_done, data);
513 - g_free(input);
552 + pre = g_strconcat(pw, "\n", NULL);
514 553 g_free(pw);
515 - } else {
516 - pw_spawn((const char *const *) argv, NULL, on_line, on_done, data);
517 554 }
555 + PwPty *pty = pw_pty_spawn((const char *const *) argv, pre, on_line, on_done,
556 + data);
557 + g_free(pre);
518 558 g_strfreev(argv);
559 + if (!pty) {
560 + if (on_line)
561 + on_line("! Nie udało się uruchomić polecenia.", data);
562 + if (on_done)
563 + on_done(127, data);
564 + }
565 + return pty;
519 566 }
520 567
521 568 /* ── Sprawdzenie aktualizacji ────────────────────────────────────────────── */
@@ -553,6 +600,22 @@ on_check_done(int status, gpointer data)
553 600 pw_tr("update_failed"));
554 601 }
555 602
603 +static void
604 +on_check_sync_done(int status, gpointer data)
605 +{
606 + App *app = data;
607 + update_release_pty(app);
608 + if (status != 0) {
609 + update_set_busy(app, FALSE);
610 + gtk_label_set_text(GTK_LABEL(app->update_result),
611 + pw_tr("update_failed"));
612 + return;
613 + }
614 + /* Po synchronizacji liczymy dostępne aktualizacje backendem. */
615 + const char *args[] = {"updates", NULL};
616 + pw_backend(args, on_check_line, on_check_done, app);
617 +}
618 +
556 619 static void
557 620 on_update_check_clicked(GtkButton *btn, gpointer data)
558 621 {
@@ -564,10 +627,9 @@ on_update_check_clicked(GtkButton *btn, gpointer data)
564 627 log_append(app->update_log, pw_tr("update_sync"), "hdr");
565 628 const char *cmd[] = {"/usr/bin/env", "PAG_YES=1", pw_pag_path(), "update",
566 629 NULL};
567 - run_privileged(app, cmd, on_update_line, NULL, app);
568 - /* Po synchronizacji liczymy aktualizacje backendem. */
569 - const char *args[] = {"updates", NULL};
570 - pw_backend(args, on_check_line, on_check_done, app);
630 + update_release_pty(app);
631 + app->update_pty = run_privileged_pty(app, cmd, on_update_line,
632 + on_check_sync_done, app);
571 633 }
572 634
573 635 /* ── Pełna aktualizacja ──────────────────────────────────────────────────── */
@@ -575,6 +637,7 @@ static void
575 637 on_upgrade_done(int status, gpointer data)
576 638 {
577 639 App *app = data;
640 + update_release_pty(app);
578 641 update_set_busy(app, FALSE);
579 642 if (status == 0) {
580 643 log_append(app->update_log, pw_tr("update_done"), "ok");
@@ -591,6 +654,7 @@ static void
591 654 on_sync_done(int status, gpointer data)
592 655 {
593 656 App *app = data;
657 + update_release_pty(app);
594 658 if (status != 0) {
595 659 update_set_busy(app, FALSE);
596 660 log_append(app->update_log, pw_tr("update_failed"), "err");
@@ -601,7 +665,8 @@ on_sync_done(int status, gpointer data)
601 665 log_append(app->update_log, pw_tr("update_upgrade"), "hdr");
602 666 const char *cmd[] = {"/usr/bin/env", "PAG_YES=1", pw_pag_path(), "upgrade",
603 667 NULL};
604 - run_privileged(app, cmd, on_update_line, on_upgrade_done, app);
668 + app->update_pty = run_privileged_pty(app, cmd, on_update_line,
669 + on_upgrade_done, app);
605 670 }
606 671
607 672 static void
@@ -623,12 +688,14 @@ on_update_clicked(GtkButton *btn, gpointer data)
623 688 log_append(app->update_log, pw_tr("update_sync"), "hdr");
624 689 const char *cmd[] = {"/usr/bin/env", "PAG_YES=1", pw_pag_path(), "update",
625 690 NULL};
626 - run_privileged(app, cmd, on_update_line, on_sync_done, app);
691 + update_release_pty(app);
692 + app->update_pty = run_privileged_pty(app, cmd, on_update_line, on_sync_done,
693 + app);
627 694 }
628 695
629 696 /* Otwórz polecenie w emulatorze terminala (pełny TTY, kolory, paski postępu).
630 - * Używane dla aktualizacji, gdy użytkownik woli widzieć przebieg w terminalu. */
631 -static void
697 + * Używane m.in. dla narzędzia Wi-Fi (pagan-wifi). TRUE, jeśli uruchomiono. */
698 +static gboolean
632 699 open_in_terminal(const char *const words[])
633 700 {
634 701 static const struct {
@@ -650,28 +717,33 @@ open_in_terminal(const char *const words[])
650 717 g_ptr_array_add(arr, NULL);
651 718 pw_spawn((const char *const *) arr->pdata, NULL, NULL, NULL, NULL);
652 719 g_ptr_array_free(arr, TRUE);
653 - return;
720 + return TRUE;
654 721 }
722 + return FALSE;
655 723 }
656 724
657 725 static void
658 -on_update_terminal_clicked(GtkButton *btn, gpointer data)
726 +on_update_cancel_clicked(GtkButton *btn, gpointer data)
659 727 {
660 728 (void) btn;
661 - (void) data;
662 - const char *words[6];
663 - int n = 0;
664 - if (!pw_is_root())
665 - words[n++] = "sudo";
666 - if (pw_have("pagan-update"))
667 - words[n++] = "pagan-update";
668 - else {
669 - words[n++] = "/bin/sh";
670 - words[n++] = "-c";
671 - words[n++] = "pag update && pag upgrade";
729 + App *app = data;
730 + if (app->update_pty && pw_pty_alive(app->update_pty)) {
731 + log_append(app->update_log, pw_tr("update_cancelled"), "warn");
732 + pw_pty_cancel(app->update_pty);
672 733 }
673 - words[n] = NULL;
674 - open_in_terminal(words);
734 +}
735 +
736 +/* Wyślij wpisaną odpowiedź na wejście procesu pag (gdyby o coś pytał). */
737 +static void
738 +on_update_input_activate(GtkEntry *e, gpointer data)
739 +{
740 + App *app = data;
741 + if (!app->update_pty || !pw_pty_alive(app->update_pty))
742 + return;
743 + char *line = g_strconcat(gtk_entry_get_text(e), "\n", NULL);
744 + pw_pty_write(app->update_pty, line);
745 + g_free(line);
746 + gtk_entry_set_text(e, "");
675 747 }
676 748
677 749 /* ── Sklep ───────────────────────────────────────────────────────────────── */
@@ -798,6 +870,84 @@ store_show_details(App *app)
798 870 g_free(e_desc);
799 871 }
800 872
873 +/* ── Detekcja wersji graficznej (przycisk „Otwórz”) ──────────────────────── */
874 +/* Ustaw widoczność/aktywność przycisków wg stanu zaznaczenia i wersji GUI:
875 + * niezainstalowany → „Zainstaluj”
876 + * zainstalowany + GUI → „Otwórz” + „Usuń”
877 + * zainstalowany bez GUI → „Usuń” */
878 +static void
879 +store_update_buttons(App *app)
880 +{
881 + const char *name = app->store_selected;
882 + gboolean selected = (name != NULL);
883 + gboolean inst = selected && app->installed &&
884 + g_hash_table_contains(app->installed, name);
885 +
886 + g_free(app->store_open_exec);
887 + app->store_open_exec = NULL;
888 + if (selected && app->gui_cache) {
889 + const char *exec = g_hash_table_lookup(app->gui_cache, name);
890 + if (exec && *exec)
891 + app->store_open_exec = g_strdup(exec);
892 + }
893 +
894 + gtk_widget_set_visible(app->store_install_btn, selected && !inst);
895 + gtk_widget_set_sensitive(app->store_install_btn, selected && !inst);
896 + gtk_widget_set_visible(app->store_remove_btn, inst);
897 + gtk_widget_set_sensitive(app->store_remove_btn, inst);
898 + gboolean open = inst && app->store_open_exec != NULL;
899 + gtk_widget_set_visible(app->store_open_btn, open);
900 + gtk_widget_set_sensitive(app->store_open_btn, open);
901 +}
902 +
903 +typedef struct {
904 + App *app;
905 + char *name;
906 + char *exec;
907 +} GuiQuery;
908 +
909 +static void
910 +store_gui_line(const char *line, gpointer data)
911 +{
912 + GuiQuery *q = data;
913 + char **f = split_tabs(line);
914 + if (g_strcmp0(f[0], "DESKTOP") == 0 && f[2]) {
915 + g_free(q->exec);
916 + q->exec = g_strdup(f[2]);
917 + }
918 + g_strfreev(f);
919 +}
920 +
921 +static void
922 +store_gui_done(int status, gpointer data)
923 +{
924 + (void) status;
925 + GuiQuery *q = data;
926 + App *app = q->app;
927 + if (!app->gui_cache)
928 + app->gui_cache = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
929 + g_free);
930 + if (!g_hash_table_contains(app->gui_cache, q->name))
931 + g_hash_table_insert(app->gui_cache, g_strdup(q->name),
932 + g_strdup(q->exec ? q->exec : ""));
933 + if (g_strcmp0(app->store_selected, q->name) == 0)
934 + store_update_buttons(app);
935 + g_free(q->exec);
936 + g_free(q->name);
937 + g_free(q);
938 +}
939 +
940 +/* Zapytaj backend, czy pakiet ma wersję graficzną (plik .desktop). */
941 +static void
942 +store_query_gui(App *app, const char *name)
943 +{
944 + GuiQuery *q = g_new0(GuiQuery, 1);
945 + q->app = app;
946 + q->name = g_strdup(name);
947 + const char *args[] = {"pkgfiles", name, NULL};
948 + pw_backend(args, store_gui_line, store_gui_done, q);
949 +}
950 +
801 951 static void
802 952 on_store_selection(GtkTreeSelection *sel, gpointer data)
803 953 {
@@ -812,6 +962,13 @@ on_store_selection(GtkTreeSelection *sel, gpointer data)
812 962 app->store_selected = NULL;
813 963 }
814 964 store_show_details(app);
965 + store_update_buttons(app);
966 + /* Dla zainstalowanego pakietu dociągnij informację o wersji graficznej. */
967 + if (app->store_selected && app->installed &&
968 + g_hash_table_contains(app->installed, app->store_selected) &&
969 + app->gui_cache &&
970 + !g_hash_table_contains(app->gui_cache, app->store_selected))
971 + store_query_gui(app, app->store_selected);
815 972 }
816 973
817 974 static void
@@ -877,6 +1034,12 @@ store_on_done(int status, gpointer data)
877 1034 store_rebuild_view(app);
878 1035 if (app->store_selected)
879 1036 store_show_details(app);
1037 + store_update_buttons(app);
1038 + if (app->store_selected && app->installed &&
1039 + g_hash_table_contains(app->installed, app->store_selected) &&
1040 + app->gui_cache &&
1041 + !g_hash_table_contains(app->gui_cache, app->store_selected))
1042 + store_query_gui(app, app->store_selected);
880 1043 }
881 1044
882 1045 static void
@@ -887,6 +1050,9 @@ store_load(App *app)
887 1050 package_free);
888 1051 app->installed = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
889 1052 g_free);
1053 + if (app->gui_cache)
1054 + g_hash_table_remove_all(app->gui_cache);
1055 + store_update_buttons(app);
890 1056 gtk_label_set_text(GTK_LABEL(app->store_count), pw_tr("store_loading"));
891 1057 const char *args[] = {"repo", NULL};
892 1058 pw_backend(args, store_on_line, store_on_done, app);
@@ -918,6 +1084,10 @@ store_action_done(int status, gpointer data)
918 1084 {
919 1085 StoreAction *act = data;
920 1086 App *app = act->app;
1087 + if (app->store_pty) {
1088 + pw_pty_free(app->store_pty);
1089 + app->store_pty = NULL;
1090 + }
921 1091 if (status == 0) {
922 1092 char *msg = g_strdup_printf(pw_tr(act->ok_key), act->name);
923 1093 log_append(app->store_log, msg, "ok");
@@ -954,8 +1124,14 @@ store_run_pkg_action(App *app, const char *action, const char *ok_key,
954 1124
955 1125 const char *cmd[] = {"/usr/bin/env", "PAG_YES=1", pw_pag_path(), action,
956 1126 "-y", app->store_selected, NULL};
957 - /* pag install/remove wymaga root – uruchamiamy przez warstwę uprawnień. */
958 - run_privileged(app, cmd, store_action_line, store_action_done, act);
1127 + /* pag install/remove wymaga root. Uruchamiamy w pseudo-terminalu – pag
1128 + * widzi TTY (nie zawiesza się) i nie blokuje menedżera pakietów. */
1129 + if (app->store_pty) {
1130 + pw_pty_free(app->store_pty);
1131 + app->store_pty = NULL;
1132 + }
1133 + app->store_pty = run_privileged_pty(app, cmd, store_action_line,
1134 + store_action_done, act);
959 1135 }
960 1136
961 1137 static void
@@ -996,173 +1172,51 @@ on_store_remove(GtkButton *btn, gpointer data)
996 1172 store_run_pkg_action(app, "remove", "store_remove_ok", "store_remove_fail");
997 1173 }
998 1174
999 -/* ── Ustawienia ──────────────────────────────────────────────────────────── */
1000 -static void
1001 -settings_fill_timezones(App *app)
1002 -{
1003 - /* Synchronicznie – lista stref jest potrzebna od razu, a zapytanie trwa
1004 - * milisekundy (bez sieci). */
1005 - char *out = pw_run_capture((const char *const[]) {
1006 - pw_backend_path(), "timezones", NULL});
1007 - if (!out)
1008 - return;
1009 - char **lines = g_strsplit(out, "\n", -1);
1010 - for (gsize i = 0; lines[i]; i++) {
1011 - char **f = split_tabs(lines[i]);
1012 - if (g_strcmp0(f[0], "TZ") == 0 && f[1])
1013 - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(app->set_tz_combo),
1014 - f[1]);
1015 - g_strfreev(f);
1016 - }
1017 - g_strfreev(lines);
1018 - g_free(out);
1019 -}
1020 -
1175 +/* ── Sklep: uruchamianie aplikacji (przycisk „Otwórz”) ──────────────────── */
1176 +/* Odłącz potomka od naszej sesji (nowa sesja + /dev/null na stdio), by
1177 + * uruchomiona aplikacja nie zginęła razem z Pagan-Welcome. */
1021 1178 static void
1022 -settings_on_line(const char *line, gpointer data)
1179 +detach_child_setup(gpointer data)
1023 1180 {
1024 - App *app = data;
1025 - char **f = split_tabs(line);
1026 - if (g_strcmp0(f[0], "LOCALE") == 0 && f[1] && *f[1]) {
1027 - gtk_combo_box_set_active(GTK_COMBO_BOX(app->set_lang_combo),
1028 - g_strcmp0(f[1], "en") == 0 ? 1 : 0);
1029 - } else if (g_strcmp0(f[0], "KEYMAP") == 0 && f[1]) {
1030 - gtk_entry_set_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(app->set_keymap_combo))),
1031 - f[1]);
1032 - } else if (g_strcmp0(f[0], "TIMEZONE") == 0 && f[1]) {
1033 - GtkWidget *entry = gtk_bin_get_child(GTK_BIN(app->set_tz_combo));
1034 - gtk_entry_set_text(GTK_ENTRY(entry), f[1]);
1035 - } else if (g_strcmp0(f[0], "HOSTNAME") == 0 && f[1]) {
1036 - gtk_entry_set_text(GTK_ENTRY(app->set_host_entry), f[1]);
1181 + (void) data;
1182 + setsid();
1183 + int devnull = open("/dev/null", O_RDWR);
1184 + if (devnull >= 0) {
1185 + dup2(devnull, STDIN_FILENO);
1186 + dup2(devnull, STDOUT_FILENO);
1187 + dup2(devnull, STDERR_FILENO);
1188 + if (devnull > 2)
1189 + close(devnull);
1037 1190 }
1038 - g_strfreev(f);
1039 1191 }
1040 1192
1193 +/* Uruchom graficzną aplikację pakietu (Exec z jego pliku .desktop). */
1041 1194 static void
1042 -settings_on_done(int status, gpointer data)
1043 -{
1044 - (void) status;
1045 - App *app = data;
1046 - gtk_label_set_text(GTK_LABEL(app->set_status), "");
1047 -}
1048 -
1049 -static void
1050 -settings_load(App *app)
1051 -{
1052 - gtk_label_set_text(GTK_LABEL(app->set_status), pw_tr("settings_loading"));
1053 - const char *args[] = {"sysinfo", NULL};
1054 - pw_backend(args, settings_on_line, settings_on_done, app);
1055 -}
1056 -
1057 -static void
1058 -on_settings_apply_done(int status, gpointer data)
1195 +on_store_open(GtkButton *btn, gpointer data)
1059 1196 {
1197 + (void) btn;
1060 1198 App *app = data;
1061 - if (status == 0)
1062 - gtk_label_set_text(GTK_LABEL(app->set_status), pw_tr("settings_saved"));
1063 - else
1064 - gtk_label_set_text(GTK_LABEL(app->set_status), pw_tr("settings_failed"));
1065 -}
1066 -
1067 -/* Wartość bezpieczna do wstawienia w polecenie powłoki: litery/cyfry oraz
1068 - * znaki z `extra`. Chroni przed wstrzyknięciem poleceń z pól formularza. */
1069 -static gboolean
1070 -valid_setting_value(const char *value, const char *extra)
1071 -{
1072 - if (!value || !*value)
1073 - return FALSE;
1074 - for (const char *p = value; *p; p++) {
1075 - if (g_ascii_isalnum(*p) || strchr(extra, *p))
1076 - continue;
1077 - return FALSE;
1199 + if (!app->store_open_exec || !*app->store_open_exec)
1200 + return;
1201 + const char *argv[] = {"/bin/sh", "-c", app->store_open_exec, NULL};
1202 + GError *err = NULL;
1203 + if (!g_spawn_async(NULL, (char **) argv, NULL, G_SPAWN_SEARCH_PATH,
1204 + detach_child_setup, NULL, NULL, &err)) {
1205 + char *msg = g_strdup_printf(pw_tr("store_open_fail"),
1206 + app->store_open_exec);
1207 + log_append(app->store_log, msg, "err");
1208 + g_free(msg);
1209 + g_clear_error(&err);
1078 1210 }
1079 - return TRUE;
1080 1211 }
1081 1212
1213 +/* ── Wi-Fi (przycisk w nagłówku) ─────────────────────────────────────────── */
1082 1214 static void
1083 -on_settings_apply(GtkButton *btn, gpointer data)
1084 -{
1085 - (void) btn;
1086 - App *app = data;
1087 -
1088 - const char *langs[] = {"pl", "en"};
1089 - const char *locales[] = {"pl_PL.UTF-8", "en_US.UTF-8"};
1090 - int li = gtk_combo_box_get_active(GTK_COMBO_BOX(app->set_lang_combo));
1091 - if (li < 0 || li > 1)
1092 - li = 0;
1093 -
1094 - /* Język interfejsu zapisujemy od razu (bez root). */
1095 - pw_i18n_set_lang(langs[li]);
1096 - g_free(app->cfg->lang);
1097 - app->cfg->lang = g_strdup(langs[li]);
1098 - pw_config_save(app->cfg);
1099 - gtk_combo_box_set_active(GTK_COMBO_BOX(app->lang_combo), li);
1100 - retranslate(app);
1101 -
1102 - char *locale = g_strdup_printf("LANG=%s", locales[li]);
1103 - const char *keymap = gtk_entry_get_text(
1104 - GTK_ENTRY(gtk_bin_get_child(GTK_BIN(app->set_keymap_combo))));
1105 - const char *tz = gtk_entry_get_text(
1106 - GTK_ENTRY(gtk_bin_get_child(GTK_BIN(app->set_tz_combo))));
1107 - const char *host = gtk_entry_get_text(GTK_ENTRY(app->set_host_entry));
1108 -
1109 - /* Walidacja: wartości trafiają do polecenia powłoki. */
1110 - if (keymap && *keymap && !valid_setting_value(keymap, ",+- "))
1111 - keymap = NULL;
1112 - if (tz && *tz && !valid_setting_value(tz, "/_+- "))
1113 - tz = NULL;
1114 - if (host && *host && !valid_setting_value(host, ".-"))
1115 - host = NULL;
1116 -
1117 - gtk_label_set_text(GTK_LABEL(app->set_status), pw_tr("common_working"));
1118 -
1119 - /* Kolejne kroki uruchamiamy szeregowo – każde własne pytanie o hasło
1120 - * byłoby uciążliwe, więc gdy trzeba hasła, robimy wszystkie w jednym
1121 - * poleceniu powłoki. */
1122 - GPtrArray *cmd = g_ptr_array_new();
1123 - GPtrArray *parts = g_ptr_array_new_with_free_func(g_free);
1124 - g_ptr_array_add(parts, g_strdup_printf("localectl set-locale %s", locale));
1125 - if (keymap && *keymap)
1126 - g_ptr_array_add(parts, g_strdup_printf("localectl set-x11-keymap %s",
1127 - keymap));
1128 - if (tz && *tz)
1129 - g_ptr_array_add(parts, g_strdup_printf("timedatectl set-timezone %s", tz));
1130 - if (host && *host)
1131 - g_ptr_array_add(parts, g_strdup_printf("hostnamectl set-hostname %s",
1132 - host));
1133 - g_ptr_array_add(parts, NULL);
1134 - char *joined = g_strjoinv(" && ", (char **) parts->pdata);
1135 -
1136 - g_ptr_array_add(cmd, g_strdup("/bin/sh"));
1137 - g_ptr_array_add(cmd, g_strdup("-c"));
1138 - g_ptr_array_add(cmd, g_strdup(joined));
1139 - g_ptr_array_add(cmd, NULL);
1140 - run_privileged(app, (const char *const *) cmd->pdata, NULL,
1141 - on_settings_apply_done, app);
1142 -
1143 - g_ptr_array_free(parts, TRUE);
1144 - g_ptr_array_free(cmd, TRUE);
1145 - g_free(joined);
1146 - g_free(locale);
1147 -}
1148 -
1149 -static void
1150 -on_settings_wifi(GtkButton *btn, gpointer data)
1215 +open_wifi_tool(void)
1151 1216 {
1152 - (void) btn;
1153 - (void) data;
1154 - const char *terms[][3] = {
1155 - {"xfce4-terminal", "-e", "pagan-wifi"},
1156 - {"x-terminal-emulator", "-e", "pagan-wifi"},
1157 - {"xterm", "-e", "pagan-wifi"},
1158 - };
1159 - for (gsize i = 0; i < G_N_ELEMENTS(terms); i++) {
1160 - if (!pw_have(terms[i][0]))
1161 - continue;
1162 - const char *argv[] = {terms[i][0], terms[i][1], terms[i][2], NULL};
1163 - pw_spawn(argv, NULL, NULL, NULL, NULL);
1217 + const char *words[] = {"pagan-wifi", NULL};
1218 + if (open_in_terminal(words))
1164 1219 return;
1165 - }
1166 1220 GtkWidget *dlg = gtk_message_dialog_new(
1167 1221 GTK_WINDOW(g_app->window), GTK_DIALOG_MODAL, GTK_MESSAGE_INFO,
1168 1222 GTK_BUTTONS_CLOSE, "%s", pw_tr("settings_network_hint"));
@@ -1170,6 +1224,14 @@ on_settings_wifi(GtkButton *btn, gpointer data)
1170 1224 gtk_widget_destroy(dlg);
1171 1225 }
1172 1226
1227 +static void
1228 +on_wifi_clicked(GtkButton *btn, gpointer data)
1229 +{
1230 + (void) btn;
1231 + (void) data;
1232 + open_wifi_tool();
1233 +}
1234 +
1173 1235 /* ── „Nie pokazuj więcej" ────────────────────────────────────────────────── */
1174 1236 static void
1175 1237 on_dont_show_toggled(GtkToggleButton *btn, gpointer data)
@@ -1229,20 +1291,35 @@ build_update_page(App *app)
1229 1291 GtkWidget *bar = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
1230 1292 app->update_check_btn = gtk_button_new_with_label(pw_tr("update_check_button"));
1231 1293 app->update_btn = gtk_button_new_with_label(pw_tr("update_button"));
1232 - app->update_terminal_btn = gtk_button_new_with_label(
1233 - pw_tr("update_terminal_button"));
1294 + app->update_cancel_btn = gtk_button_new_with_label(pw_tr("common_cancel"));
1234 1295 tr_register(app, app->update_check_btn, "update_check_button", FALSE);
1235 1296 tr_register(app, app->update_btn, "update_button", FALSE);
1236 - tr_register(app, app->update_terminal_btn, "update_terminal_button", FALSE);
1297 + tr_register(app, app->update_cancel_btn, "common_cancel", FALSE);
1298 + gtk_widget_set_sensitive(app->update_cancel_btn, FALSE);
1237 1299 app->update_result = gtk_label_new("");
1238 1300 gtk_box_pack_start(GTK_BOX(bar), app->update_check_btn, FALSE, FALSE, 0);
1239 1301 gtk_box_pack_start(GTK_BOX(bar), app->update_btn, FALSE, FALSE, 0);
1240 - gtk_box_pack_start(GTK_BOX(bar), app->update_terminal_btn, FALSE, FALSE, 0);
1302 + gtk_box_pack_start(GTK_BOX(bar), app->update_cancel_btn, FALSE, FALSE, 0);
1241 1303 gtk_box_pack_start(GTK_BOX(bar), app->update_result, FALSE, FALSE, 10);
1242 1304 gtk_box_pack_start(GTK_BOX(box), bar, FALSE, FALSE, 4);
1243 1305
1244 - app->update_log = log_new(240);
1306 + /* Terminal aktualizacji: podglad przebiegu pag na żywo. */
1307 + app->update_log = log_new(220);
1245 1308 gtk_box_pack_start(GTK_BOX(box), app->update_log, TRUE, TRUE, 4);
1309 +
1310 + /* Pole odpowiedzi – gdyby pag o coś spytał mimo PAG_YES. */
1311 + app->update_input = gtk_entry_new();
1312 + gtk_entry_set_placeholder_text(GTK_ENTRY(app->update_input),
1313 + pw_tr("update_input_placeholder"));
1314 + tr_register_placeholder(app, app->update_input,
1315 + "update_input_placeholder");
1316 + gtk_widget_set_sensitive(app->update_input, FALSE);
1317 + gtk_box_pack_start(GTK_BOX(box), app->update_input, FALSE, FALSE, 0);
1318 +
1319 + g_signal_connect(app->update_cancel_btn, "clicked",
1320 + G_CALLBACK(on_update_cancel_clicked), app);
1321 + g_signal_connect(app->update_input, "activate",
1322 + G_CALLBACK(on_update_input_activate), app);
1246 1323 return box;
1247 1324 }
1248 1325
@@ -1259,6 +1336,7 @@ build_store_page(App *app)
1259 1336 app->store_search = gtk_search_entry_new();
1260 1337 gtk_entry_set_placeholder_text(GTK_ENTRY(app->store_search),
1261 1338 pw_tr("store_search_placeholder"));
1339 + tr_register_placeholder(app, app->store_search, "store_search_placeholder");
1262 1340 GtkWidget *refresh = gtk_button_new_with_label(pw_tr("common_refresh"));
1263 1341 tr_register(app, refresh, "common_refresh", FALSE);
1264 1342 gtk_box_pack_start(GTK_BOX(bar), app->store_search, TRUE, TRUE, 0);
@@ -1322,12 +1400,19 @@ build_store_page(App *app)
1322 1400 gtk_label_set_line_wrap(GTK_LABEL(app->store_details), TRUE);
1323 1401 gtk_label_set_selectable(GTK_LABEL(app->store_details), TRUE);
1324 1402 gtk_box_pack_start(GTK_BOX(right), app->store_details, TRUE, TRUE, 0);
1403 + app->store_open_btn = gtk_button_new_with_label(pw_tr("store_open"));
1325 1404 app->store_install_btn = gtk_button_new_with_label(pw_tr("store_install"));
1326 1405 app->store_remove_btn = gtk_button_new_with_label(pw_tr("store_remove"));
1406 + tr_register(app, app->store_open_btn, "store_open", FALSE);
1327 1407 tr_register(app, app->store_install_btn, "store_install", FALSE);
1328 1408 tr_register(app, app->store_remove_btn, "store_remove", FALSE);
1409 + gtk_box_pack_start(GTK_BOX(right), app->store_open_btn, FALSE, FALSE, 0);
1329 1410 gtk_box_pack_start(GTK_BOX(right), app->store_install_btn, FALSE, FALSE, 0);
1330 1411 gtk_box_pack_start(GTK_BOX(right), app->store_remove_btn, FALSE, FALSE, 0);
1412 + /* Stan początkowy: nic nie zaznaczone – wszystkie akcje ukryte. */
1413 + gtk_widget_set_visible(app->store_open_btn, FALSE);
1414 + gtk_widget_set_visible(app->store_install_btn, FALSE);
1415 + gtk_widget_set_visible(app->store_remove_btn, FALSE);
1331 1416 gtk_paned_pack2(GTK_PANED(paned), right, FALSE, FALSE);
1332 1417 gtk_paned_set_position(GTK_PANED(paned), 560);
1333 1418 gtk_box_pack_start(GTK_BOX(box), paned, TRUE, TRUE, 4);
@@ -1342,101 +1427,8 @@ build_store_page(App *app)
1342 1427 G_CALLBACK(on_store_install), app);
1343 1428 g_signal_connect(app->store_remove_btn, "clicked",
1344 1429 G_CALLBACK(on_store_remove), app);
1345 - return box;
1346 -}
1347 -
1348 -static GtkWidget *
1349 -build_settings_page(App *app)
1350 -{
1351 - GtkWidget *box = page_box();
1352 - GList *kids = gtk_container_get_children(GTK_CONTAINER(box));
1353 - tr_register(app, GTK_WIDGET(g_list_nth_data(kids, 0)), "settings_title", TRUE);
1354 - tr_register(app, GTK_WIDGET(g_list_nth_data(kids, 1)), "settings_subtitle",
1355 - TRUE);
1356 - g_list_free(kids);
1357 -
1358 - GtkWidget *grid = gtk_grid_new();
1359 - gtk_grid_set_row_spacing(GTK_GRID(grid), 8);
1360 - gtk_grid_set_column_spacing(GTK_GRID(grid), 12);
1361 - gtk_box_pack_start(GTK_BOX(box), grid, FALSE, FALSE, 6);
1362 -
1363 - GtkWidget *l;
1364 -
1365 - l = gtk_label_new(pw_tr("settings_language"));
1366 - gtk_label_set_xalign(GTK_LABEL(l), 0.0);
1367 - tr_register(app, l, "settings_language", TRUE);
1368 - gtk_grid_attach(GTK_GRID(grid), l, 0, 0, 1, 1);
1369 - app->set_lang_combo = gtk_combo_box_text_new();
1370 - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(app->set_lang_combo),
1371 - "Polski");
1372 - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(app->set_lang_combo),
1373 - "English");
1374 - gtk_grid_attach(GTK_GRID(grid), app->set_lang_combo, 1, 0, 1, 1);
1375 -
1376 - l = gtk_label_new(pw_tr("settings_keyboard"));
1377 - gtk_label_set_xalign(GTK_LABEL(l), 0.0);
1378 - tr_register(app, l, "settings_keyboard", TRUE);
1379 - gtk_grid_attach(GTK_GRID(grid), l, 0, 1, 1, 1);
1380 - app->set_keymap_combo = gtk_combo_box_text_new_with_entry();
1381 - static const char *keymaps[] = {"pl", "us", "gb", "de", "fr", "es", "it",
1382 - "ru", "ua", "cz", "sk", "nl", "se", "pt"};
1383 - for (gsize i = 0; i < G_N_ELEMENTS(keymaps); i++)
1384 - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(app->set_keymap_combo),
1385 - keymaps[i]);
1386 - gtk_grid_attach(GTK_GRID(grid), app->set_keymap_combo, 1, 1, 1, 1);
1387 -
1388 - l = gtk_label_new(pw_tr("settings_timezone"));
1389 - gtk_label_set_xalign(GTK_LABEL(l), 0.0);
1390 - tr_register(app, l, "settings_timezone", TRUE);
1391 - gtk_grid_attach(GTK_GRID(grid), l, 0, 2, 1, 1);
1392 - app->set_tz_combo = gtk_combo_box_text_new_with_entry();
1393 - gtk_grid_attach(GTK_GRID(grid), app->set_tz_combo, 1, 2, 1, 1);
1394 -
1395 - l = gtk_label_new(pw_tr("settings_hostname"));
1396 - gtk_label_set_xalign(GTK_LABEL(l), 0.0);
1397 - tr_register(app, l, "settings_hostname", TRUE);
1398 - gtk_grid_attach(GTK_GRID(grid), l, 0, 3, 1, 1);
1399 - app->set_host_entry = gtk_entry_new();
1400 - gtk_grid_attach(GTK_GRID(grid), app->set_host_entry, 1, 3, 1, 1);
1401 -
1402 - l = gtk_label_new(pw_tr("settings_network"));
1403 - gtk_label_set_xalign(GTK_LABEL(l), 0.0);
1404 - tr_register(app, l, "settings_network", TRUE);
1405 - gtk_grid_attach(GTK_GRID(grid), l, 0, 4, 1, 1);
1406 - app->set_wifi_btn = gtk_button_new_with_label(pw_tr("settings_wifi_button"));
1407 - tr_register(app, app->set_wifi_btn, "settings_wifi_button", FALSE);
1408 - gtk_widget_set_halign(app->set_wifi_btn, GTK_ALIGN_START);
1409 - gtk_grid_attach(GTK_GRID(grid), app->set_wifi_btn, 1, 4, 1, 1);
1410 -
1411 - GtkWidget *bar = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);
1412 - app->set_apply_btn = gtk_button_new_with_label(pw_tr("settings_apply"));
1413 - tr_register(app, app->set_apply_btn, "settings_apply", FALSE);
1414 - app->set_status = gtk_label_new("");
1415 - gtk_box_pack_start(GTK_BOX(bar), app->set_apply_btn, FALSE, FALSE, 0);
1416 - gtk_box_pack_start(GTK_BOX(bar), app->set_status, FALSE, FALSE, 0);
1417 - gtk_box_pack_start(GTK_BOX(box), bar, FALSE, FALSE, 10);
1418 -
1419 - GtkWidget *hint = gtk_label_new(pw_tr("settings_restart_hint"));
1420 - gtk_label_set_xalign(GTK_LABEL(hint), 0.0);
1421 - gtk_widget_set_opacity(hint, 0.6);
1422 - tr_register(app, hint, "settings_restart_hint", TRUE);
1423 - gtk_box_pack_start(GTK_BOX(box), hint, FALSE, FALSE, 0);
1424 -
1425 - GtkWidget *about = gtk_label_new(NULL);
1426 - gtk_label_set_xalign(GTK_LABEL(about), 0.0);
1427 - gtk_label_set_line_wrap(GTK_LABEL(about), TRUE);
1428 - char *about_txt = g_strdup_printf("<b>%s</b>\n%s", pw_tr("settings_about"),
1429 - pw_tr("settings_about_text"));
1430 - gtk_label_set_markup(GTK_LABEL(about), about_txt);
1431 - g_free(about_txt);
1432 - gtk_box_pack_start(GTK_BOX(box), about, FALSE, FALSE, 12);
1433 -
1434 - g_signal_connect(app->set_apply_btn, "clicked",
1435 - G_CALLBACK(on_settings_apply), app);
1436 - g_signal_connect(app->set_wifi_btn, "clicked",
1437 - G_CALLBACK(on_settings_wifi), app);
1438 -
1439 - settings_fill_timezones(app);
1430 + g_signal_connect(app->store_open_btn, "clicked",
1431 + G_CALLBACK(on_store_open), app);
1440 1432 return box;
1441 1433 }
1442 1434
@@ -1499,9 +1491,8 @@ build_sidebar(App *app)
1499 1491 {
1500 1492 GtkWidget *lb = gtk_list_box_new();
1501 1493 gtk_list_box_set_selection_mode(GTK_LIST_BOX(lb), GTK_SELECTION_SINGLE);
1502 - const char *pages[] = {"news", "install", "update", "store", "settings"};
1503 - const char *keys[] = {"nav_news", "nav_install", "nav_update", "nav_store",
1504 - "nav_settings"};
1494 + const char *pages[] = {"news", "install", "update", "store"};
1495 + const char *keys[] = {"nav_news", "nav_install", "nav_update", "nav_store"};
1505 1496 /* Instalator ma sens wyłącznie w środowisku live. Na zainstalowanym
1506 1497 * systemie zakładka jest bezużyteczna (przycisk i tak wyłączony), więc
1507 1498 * w ogóle jej nie pokazujemy. */
@@ -1588,6 +1579,11 @@ build_main_window(App *app)
1588 1579 gtk_box_pack_start(GTK_BOX(header), titles, FALSE, FALSE, 0);
1589 1580
1590 1581 GtkWidget *langbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
1582 + app->header_wifi_btn = gtk_button_new_with_label(pw_tr("header_wifi"));
1583 + tr_register(app, app->header_wifi_btn, "header_wifi", FALSE);
1584 + gtk_widget_set_tooltip_text(app->header_wifi_btn,
1585 + pw_tr("settings_network_hint"));
1586 + gtk_box_pack_start(GTK_BOX(langbox), app->header_wifi_btn, FALSE, FALSE, 0);
1591 1587 GtkWidget *langlbl = gtk_label_new(pw_tr("common_language"));
1592 1588 gtk_box_pack_start(GTK_BOX(langbox), langlbl, FALSE, FALSE, 0);
1593 1589 app->lang_combo = gtk_combo_box_text_new();
@@ -1621,7 +1617,6 @@ build_main_window(App *app)
1621 1617 gtk_stack_add_named(GTK_STACK(app->stack), build_install_page(app), "install");
1622 1618 gtk_stack_add_named(GTK_STACK(app->stack), build_update_page(app), "update");
1623 1619 gtk_stack_add_named(GTK_STACK(app->stack), build_store_page(app), "store");
1624 - gtk_stack_add_named(GTK_STACK(app->stack), build_settings_page(app), "settings");
1625 1620 gtk_box_pack_start(GTK_BOX(body), app->stack, TRUE, TRUE, 0);
1626 1621 gtk_box_pack_start(GTK_BOX(outer), body, TRUE, TRUE, 0);
1627 1622
@@ -1633,8 +1628,8 @@ build_main_window(App *app)
1633 1628 g_signal_connect(app->update_check_btn, "clicked",
1634 1629 G_CALLBACK(on_update_check_clicked), app);
1635 1630 g_signal_connect(app->update_btn, "clicked", G_CALLBACK(on_update_clicked), app);
1636 - g_signal_connect(app->update_terminal_btn, "clicked",
1637 - G_CALLBACK(on_update_terminal_clicked), app);
1631 + g_signal_connect(app->header_wifi_btn, "clicked",
1632 + G_CALLBACK(on_wifi_clicked), app);
1638 1633
1639 1634 /* Wybór strony i wstępne wczytanie danych. Ważna kolejność: show_all
1640 1635 * rozgłasza widoczność na WSZYSTKIE dzieci GtkStack, więc widoczną stronę
@@ -1644,7 +1639,6 @@ build_main_window(App *app)
1644 1639 install_update_state(app);
1645 1640 news_reload(app);
1646 1641 store_load(app);
1647 - settings_load(app);
1648 1642 }
1649 1643
1650 1644 /* ── Aplet tray ──────────────────────────────────────────────────────────── */
@@ -1774,14 +1768,11 @@ tray_check_clicked(GtkMenuItem *item, gpointer data)
1774 1768 }
1775 1769
1776 1770 static void
1777 -tray_open_settings(GtkMenuItem *item, gpointer data)
1771 +tray_wifi(GtkMenuItem *item, gpointer data)
1778 1772 {
1779 1773 (void) item;
1780 - App *app = data;
1781 - if (!app->window)
1782 - build_main_window(app);
1783 - gtk_window_present(GTK_WINDOW(app->window));
1784 - gtk_stack_set_visible_child_name(GTK_STACK(app->stack), "settings");
1774 + (void) data;
1775 + open_wifi_tool();
1785 1776 }
1786 1777
1787 1778 static void
@@ -1791,7 +1782,7 @@ tray_start(App *app)
1791 1782 app->tray_menu = gtk_menu_new();
1792 1783
1793 1784 const char *keys[] = {"tray_check", "tray_update", "tray_open",
1794 - "tray_settings", "tray_quit"};
1785 + "tray_wifi", "tray_quit"};
1795 1786 for (int i = 0; i < 5; i++) {
1796 1787 app->tray_items[i] = gtk_menu_item_new_with_label(pw_tr(keys[i]));
1797 1788 gtk_menu_shell_append(GTK_MENU_SHELL(app->tray_menu),
@@ -1807,7 +1798,7 @@ tray_start(App *app)
1807 1798 g_signal_connect(app->tray_items[2], "activate",
1808 1799 G_CALLBACK(tray_open_window), app);
1809 1800 g_signal_connect(app->tray_items[3], "activate",
1810 - G_CALLBACK(tray_open_settings), app);
1801 + G_CALLBACK(tray_wifi), app);
1811 1802 g_signal_connect(app->tray_items[4], "activate", G_CALLBACK(tray_quit), app);
1812 1803 gtk_widget_show_all(app->tray_menu);
1813 1804
@@ -1866,10 +1857,17 @@ app_free(App *app)
1866 1857 return;
1867 1858 pw_config_free(app->cfg);
1868 1859 g_free(app->store_selected);
1860 + g_free(app->store_open_exec);
1861 + if (app->update_pty)
1862 + pw_pty_free(app->update_pty);
1863 + if (app->store_pty)
1864 + pw_pty_free(app->store_pty);
1869 1865 if (app->packages)
1870 1866 g_hash_table_destroy(app->packages);
1871 1867 if (app->installed)
1872 1868 g_hash_table_destroy(app->installed);
1869 + if (app->gui_cache)
1870 + g_hash_table_destroy(app->gui_cache);
1873 1871 for (GList *l = app->tr_entries; l; l = g_list_next(l)) {
1874 1872 TrEntry *e = l->data;
1875 1873 g_free(e->key);
@@ -1897,7 +1895,7 @@ main(int argc, char **argv)
1897 1895 } else if (g_strcmp0(argv[i], "--help") == 0 ||
1898 1896 g_strcmp0(argv[i], "-h") == 0) {
1899 1897 g_print("Użycie: pagan-welcome [--tray|--check|--version|"
1900 - " --page <news|install|update|store|settings>]\n");
1898 + " --page <news|install|update|store>]\n");
1901 1899 return 0;
1902 1900 }
1903 1901 }
@@ -95,9 +95,13 @@ static const Entry TABLE[] = {
95 95 "Start the system update?"},
96 96 {"update_reboot", "Zalecany restart po aktualizacji jądra.",
97 97 "A reboot is recommended after a kernel update."},
98 - {"update_terminal_button", "Aktualizuj w terminalu", "Update in terminal"},
99 98 {"update_sync", "Synchronizacja repozytorium…", "Syncing repository…"},
100 99 {"update_upgrade", "Aktualizacja pakietów…", "Upgrading packages…"},
100 + {"update_terminal_title", "Terminal aktualizacji", "Update terminal"},
101 + {"update_input_placeholder", "Wpisz odpowiedź dla pag i naciśnij Enter…",
102 + "Type a reply for pag and press Enter…"},
103 + {"update_cancelled", "Przerwano aktualizację.", "Update cancelled."},
104 + {"update_waiting", "Uruchamiam aktualizację…", "Starting the update…"},
101 105
102 106 /* ── Sklep ─────────────────────────────────────────────────────────── */
103 107 {"store_title", "Sklep z pakietami", "Package store"},
@@ -133,6 +137,13 @@ static const Entry TABLE[] = {
133 137 {"store_remove_ok", "Usunięto: %s", "Removed: %s"},
134 138 {"store_remove_fail", "Nie udało się usunąć: %s", "Failed to remove: %s"},
135 139 {"store_none", "brak", "none"},
140 + {"store_open", "Otwórz", "Open"},
141 + {"store_open_hint", "Uruchom aplikację graficzną pakietu",
142 + "Launch the package's graphical application"},
143 + {"store_open_fail", "Nie udało się uruchomić: %s", "Failed to launch: %s"},
144 + {"store_status_installed_gui", "Zainstalowany • ma aplikację graficzną",
145 + "Installed • has a graphical app"},
146 + {"store_status_installed", "Zainstalowany", "Installed"},
136 147
137 148 /* ── Ustawienia ────────────────────────────────────────────────────── */
138 149 {"settings_title", "Ustawienia podstawowe", "Basic settings"},
@@ -163,6 +174,7 @@ static const Entry TABLE[] = {
163 174 {"settings_loading", "Wczytuję ustawienia…", "Loading settings…"},
164 175
165 176 /* ── Nie pokazuj więcej / autostart ────────────────────────────────── */
177 + {"header_wifi", "Wi-Fi", "Wi-Fi"},
166 178 {"dont_show_again", "Nie pokazuj tego okna przy logowaniu",
167 179 "Don't show this window at login"},
168 180 {"autostart_enabled", "Pagan-Welcome będzie się uruchamiał przy logowaniu.",
@@ -175,6 +187,7 @@ static const Entry TABLE[] = {
175 187 {"tray_update", "Aktualizuj system", "Update system"},
176 188 {"tray_open", "Otwórz Pagan-Welcome", "Open Pagan-Welcome"},
177 189 {"tray_settings", "Ustawienia", "Settings"},
190 + {"tray_wifi", "Połącz z Wi-Fi", "Connect to Wi-Fi"},
178 191 {"tray_quit", "Zakończ", "Quit"},
179 192 {"tray_updates_available", "Dostępne aktualizacje: %d",
180 193 "Available updates: %d"},
@@ -189,7 +202,7 @@ static const Entry TABLE[] = {
189 202 {"tray_tooltip", "PaganLinux – aktualizacje", "PaganLinux – updates"},
190 203 };
191 204
192 -static const char *cur_lang = "pl";
205 +static const char *cur_lang = "en";
193 206
194 207 void
195 208 pw_i18n_set_lang(const char *lang)
@@ -197,7 +210,7 @@ pw_i18n_set_lang(const char *lang)
197 210 if (lang && (g_strcmp0(lang, "en") == 0 || g_strcmp0(lang, "pl") == 0))
198 211 cur_lang = g_strcmp0(lang, "en") == 0 ? "en" : "pl";
199 212 else
200 - cur_lang = "pl";
213 + cur_lang = "en"; /* domyślnie angielski */
201 214 }
202 215
203 216 const char *
@@ -1,6 +1,6 @@
1 1 /* pagan-welcome – tłumaczenia interfejsu (PL/EN).
2 2 *
3 - * Tabela par klucz → {polski, angielski}. Brak tłumaczenia spada do polskiego,
3 + * Tabela par klucz → {polski, angielski}. Brak tłumaczenia spada do angielskiego,
4 4 * a gdy i tam klucza nie ma – zwracany jest sam klucz (łatwo wykryć braki).
5 5 */
6 6 #ifndef PW_I18N_H
@@ -8,7 +8,7 @@
8 8
9 9 #include <glib.h>
10 10
11 -/* Ustaw aktywny język ("pl"/"en"). Nieznany kod → "pl". */
11 +/* Ustaw aktywny język ("pl"/"en"). Nieznany kod → "en" (domyślny). */
12 12 void pw_i18n_set_lang(const char *lang);
13 13 const char *pw_i18n_lang(void);
14 14
@@ -1,11 +1,18 @@
1 1 /* pagan-welcome – implementacja konfiguracji i uruchamiania poleceń. */
2 +#define _GNU_SOURCE 1
2 3 #include "pw-util.h"
3 4
4 5 #include <gio/gio.h>
5 6 #include <errno.h>
7 +#include <fcntl.h>
6 8 #include <limits.h>
9 +#include <pty.h>
10 +#include <signal.h>
7 11 #include <stdio.h>
12 +#include <stdlib.h>
8 13 #include <string.h>
14 +#include <sys/wait.h>
15 +#include <termios.h>
9 16 #include <unistd.h>
10 17
11 18 /* ── Konfiguracja ────────────────────────────────────────────────────────── */
@@ -32,9 +39,9 @@ env_lang_default(void)
32 39 env = g_getenv("LC_MESSAGES");
33 40 if (!env || !*env)
34 41 env = g_getenv("LANG");
35 - if (env && g_str_has_prefix(env, "en"))
36 - return g_strdup("en");
37 - return g_strdup("pl");
42 + if (env && g_str_has_prefix(env, "pl"))
43 + return g_strdup("pl");
44 + return g_strdup("en");
38 45 }
39 46
40 47 PwConfig *
@@ -477,3 +484,255 @@ pw_format_size(guint64 bytes)
477 484 return g_strdup_printf("%" G_GUINT64_FORMAT " %s", bytes, units[u]);
478 485 return g_strdup_printf("%.1f %s", v, units[u]);
479 486 }
487 +
488 +/* ── Terminal (pseudo-tty) ───────────────────────────────────────────────── */
489 +struct PwPty {
490 + int master;
491 + pid_t pid;
492 + gboolean alive;
493 + GMutex lock;
494 + gint refs;
495 + PwLineFunc on_line;
496 + PwDoneFunc on_done;
497 + gpointer data;
498 +};
499 +
500 +/* Usuń sekwencje ANSI (kolory, sterowanie kursorem) – GtkTextView nie renderuje
501 + * escape'ów, więc surowe „\x1b[32m” zaśmiecałoby log. Zostawiamy czysty tekst. */
502 +static char *
503 +strip_ansi(const char *in)
504 +{
505 + GString *out = g_string_new(NULL);
506 + const unsigned char *p = (const unsigned char *) in;
507 + while (*p) {
508 + if (*p == 0x1b) {
509 + p++;
510 + if (*p == '[') { /* CSI: ESC [ ... litera @-~ */
511 + p++;
512 + while (*p >= 0x20 && *p <= 0x3f)
513 + p++;
514 + if (*p >= 0x40 && *p <= 0x7e)
515 + p++;
516 + } else if (*p == ']') { /* OSC: ESC ] ... BEL/ST */
517 + p++;
518 + while (*p && *p != 0x07 && *p != 0x1b)
519 + p++;
520 + if (*p == 0x07)
521 + p++;
522 + else if (*p == 0x1b)
523 + p++;
524 + } else if (*p) {
525 + p++; /* pojedynczy ESC x */
526 + }
527 + continue;
528 + }
529 + if (*p == '\r') { /* powrót karetki – pomijamy */
530 + p++;
531 + continue;
532 + }
533 + g_string_append_c(out, (char) *p);
534 + p++;
535 + }
536 + return g_string_free(out, FALSE);
537 +}
538 +
539 +static void
540 +pty_unref(PwPty *pty)
541 +{
542 + if (!pty)
543 + return;
544 + if (g_atomic_int_dec_and_test(&pty->refs)) {
545 + g_mutex_clear(&pty->lock);
546 + g_free(pty);
547 + }
548 +}
549 +
550 +static void
551 +pty_emit_line(PwPty *pty, const char *line)
552 +{
553 + if (!pty->on_line)
554 + return;
555 + LineMsg *m = g_new0(LineMsg, 1);
556 + m->func = pty->on_line;
557 + m->line = g_strdup(line);
558 + m->data = pty->data;
559 + g_idle_add(line_idle, m);
560 +}
561 +
562 +static void
563 +pty_emit_done(PwPty *pty, int status)
564 +{
565 + if (!pty->on_done)
566 + return;
567 + DoneMsg *m = g_new0(DoneMsg, 1);
568 + m->func = pty->on_done;
569 + m->status = status;
570 + m->data = pty->data;
571 + g_idle_add(done_idle, m);
572 +}
573 +
574 +static gpointer
575 +pty_thread(gpointer p)
576 +{
577 + PwPty *pty = p;
578 + GString *buf = g_string_new(NULL);
579 + char chunk[4096];
580 + ssize_t n;
581 +
582 + while ((n = read(pty->master, chunk, sizeof(chunk))) > 0) {
583 + for (ssize_t i = 0; i < n; i++) {
584 + if (chunk[i] == '\n') {
585 + char *clean = strip_ansi(buf->str);
586 + pty_emit_line(pty, clean);
587 + g_free(clean);
588 + g_string_truncate(buf, 0);
589 + } else {
590 + g_string_append_c(buf, chunk[i]);
591 + }
592 + }
593 + }
594 + if (buf->len) {
595 + char *clean = strip_ansi(buf->str);
596 + if (*clean)
597 + pty_emit_line(pty, clean);
598 + g_free(clean);
599 + }
600 + g_string_free(buf, TRUE);
601 +
602 + int status = -1;
603 + int st = 0;
604 + if (waitpid(pty->pid, &st, 0) == pty->pid) {
605 + if (WIFEXITED(st))
606 + status = WEXITSTATUS(st);
607 + else if (WIFSIGNALED(st))
608 + status = 128 + WTERMSIG(st);
609 + }
610 +
611 + g_mutex_lock(&pty->lock);
612 + pty->alive = FALSE;
613 + if (pty->master >= 0) {
614 + close(pty->master);
615 + pty->master = -1;
616 + }
617 + g_mutex_unlock(&pty->lock);
618 +
619 + pty_emit_done(pty, status);
620 + pty_unref(pty); /* zwolnij referencję wątku */
621 + return NULL;
622 +}
623 +
624 +PwPty *
625 +pw_pty_spawn(const char *const argv[], const char *initial_input,
626 + PwLineFunc on_line, PwDoneFunc on_done, gpointer data)
627 +{
628 + if (!argv || !argv[0])
629 + return NULL;
630 +
631 + PwPty *pty = g_new0(PwPty, 1);
632 + pty->master = -1;
633 + pty->refs = 1;
634 + g_mutex_init(&pty->lock);
635 + pty->on_line = on_line;
636 + pty->on_done = on_done;
637 + pty->data = data;
638 +
639 + /* Głęboka kopia argv przed forkiem – po forku wolno wywoływać wyłącznie
640 + * funkcje bezpieczne dla sygnałów, więc nie alokujemy po stronie dziecka. */
641 + gsize argc = 0;
642 + while (argv[argc])
643 + argc++;
644 + char **child_argv = g_new0(char *, argc + 1);
645 + for (gsize i = 0; i < argc; i++)
646 + child_argv[i] = g_strdup(argv[i]);
647 +
648 + int master = -1;
649 + pid_t pid = forkpty(&master, NULL, NULL, NULL);
650 + if (pid < 0) {
651 + g_strfreev(child_argv);
652 + g_mutex_clear(&pty->lock);
653 + g_free(pty);
654 + return NULL;
655 + }
656 + if (pid == 0) {
657 + /* Dziecko: forkpty dał już nową sesję z PTY jako terminalem. */
658 + setenv("TERM", "xterm-256color", 1);
659 + setenv("COLORTERM", "truecolor", 1);
660 + execvp(child_argv[0], child_argv);
661 + _exit(127);
662 + }
663 + g_strfreev(child_argv);
664 +
665 + pty->master = master;
666 + pty->pid = pid;
667 + pty->alive = TRUE;
668 +
669 + /* Wstępne wejście (np. hasło do `sudo -S`). Echo na PTY wyłączamy PRZED
670 + * zapisem, żeby hasło nie zostało odbite do logu terminala. */
671 + if (initial_input && *initial_input) {
672 + struct termios tio;
673 + if (tcgetattr(master, &tio) == 0) {
674 + tio.c_lflag &= ~ECHO;
675 + tcsetattr(master, TCSANOW, &tio);
676 + }
677 + ssize_t w = write(master, initial_input, strlen(initial_input));
678 + (void) w;
679 + }
680 +
681 + g_atomic_int_inc(&pty->refs); /* referencja wątku czytającego */
682 + g_thread_unref(g_thread_new("pw-pty", pty_thread, pty));
683 + return pty;
684 +}
685 +
686 +void
687 +pw_pty_write(PwPty *pty, const char *data)
688 +{
689 + if (!pty || !data)
690 + return;
691 + g_mutex_lock(&pty->lock);
692 + if (pty->alive && pty->master >= 0) {
693 + ssize_t w = write(pty->master, data, strlen(data));
694 + (void) w;
695 + }
696 + g_mutex_unlock(&pty->lock);
697 +}
698 +
699 +void
700 +pw_pty_cancel(PwPty *pty)
701 +{
702 + if (!pty)
703 + return;
704 + g_mutex_lock(&pty->lock);
705 + gboolean alive = pty->alive;
706 + pid_t pid = pty->pid;
707 + g_mutex_unlock(&pty->lock);
708 + if (!alive)
709 + return;
710 + /* forkpty tworzy nową sesję, więc -pid to cała grupa procesów polecenia. */
711 + kill(-pid, SIGTERM);
712 + kill(pid, SIGTERM);
713 +}
714 +
715 +gboolean
716 +pw_pty_alive(PwPty *pty)
717 +{
718 + if (!pty)
719 + return FALSE;
720 + g_mutex_lock(&pty->lock);
721 + gboolean alive = pty->alive;
722 + g_mutex_unlock(&pty->lock);
723 + return alive;
724 +}
725 +
726 +void
727 +pw_pty_free(PwPty *pty)
728 +{
729 + if (!pty)
730 + return;
731 + g_mutex_lock(&pty->lock);
732 + if (pty->alive) {
733 + kill(-pty->pid, SIGTERM);
734 + kill(pty->pid, SIGTERM);
735 + }
736 + g_mutex_unlock(&pty->lock);
737 + pty_unref(pty);
738 +}
@@ -33,6 +33,23 @@ void pw_spawn(const char *const argv[], const char *input,
33 33 void pw_backend(const char *const args[], PwLineFunc on_line,
34 34 PwDoneFunc on_done, gpointer data);
35 35
36 +/* ── Terminal (pseudo-tty) ───────────────────────────────────────────────── */
37 +/* Uruchom polecenie pod pseudo-terminalem – tak, jak w prawdziwym terminalu.
38 + * Dzięki temu `pag` widzi TTY: nie „zawiesza się” na braku wejścia, pokazuje
39 + * normalny przebieg, a użytkownik może wpisać odpowiedź i przerwać proces.
40 + * `initial_input` (jeśli nie NULL) trafia na wejście zaraz po starcie, np.
41 + * hasło dla `sudo -S`. `on_line`/`on_done` wołane są w wątku głównym.
42 + * Uchwyt zwalniaj przez pw_pty_free() (po zakończeniu lub po anulowaniu). */
43 +typedef struct PwPty PwPty;
44 +PwPty *pw_pty_spawn(const char *const argv[], const char *initial_input,
45 + PwLineFunc on_line, PwDoneFunc on_done, gpointer data);
46 +/* Wyślij tekst na wejście procesu (dopisz „\n”, by zatwierdzić linię). */
47 +void pw_pty_write(PwPty *pty, const char *data);
48 +/* Przerwij proces (SIGTERM, po chwili SIGKILL) wraz z jego procesami potomnymi. */
49 +void pw_pty_cancel(PwPty *pty);
50 +gboolean pw_pty_alive(PwPty *pty);
51 +void pw_pty_free(PwPty *pty);
52 +
36 53 /* ── Uprawnienia root ────────────────────────────────────────────────────── */
37 54 gboolean pw_is_root(void);
38 55 /* TRUE, gdy trzeba podać hasło (używamy sudo -S zamiast pkexec). */