PaganOS Luna 0.6.0
PL EN DE
← pag

Commit 73f20e5

3
plików
+818
dodanych
-89
usuniętych
@@ -1,11 +1,13 @@
1 -#!/usr/bin/env python3
1 +#!/usr/bin/env python3
2 2 """
3 3 ╔══════════════════════════════════════════════════════════════════════════════╗
4 -║ PAG - Pagan Linux Package Manager v4.0.8 ║
4 +║ PAG - Pagan Linux Package Manager v4.1.0 ║
5 5 ║ Produkcyjny menedżer pakietów – atomowy, bezpieczny, i18n ║
6 6 ╚══════════════════════════════════════════════════════════════════════════════╝
7 7
8 8 KLUCZOWE CECHY:
9 + - Transakcja grupowa: staging CAŁEJ grupy → commit (błąd paczki nie psuje systemu)
10 + - Snapshoty btrfs przed transakcją + wpisy GRUB (rollback przy starcie)
9 11 - Atomowa instalacja przez staging (tmpdir → rename) – brak pół-instalacji
10 12 - Bezpieczne usuwanie – sprawdza czy plik nie jest współdzielony
11 13 - SQLite dla bazy plików – miliony plików bez problemu
@@ -55,7 +57,7 @@ import threading, itertools
55 57 import uuid # serialNumber SBOM (CycloneDX)
56 58
57 59 # Wersja klienta – do porównania z repo.json["pag_version"] (self-update)
58 -PAG_VERSION = "4.0.9"
60 +PAG_VERSION = "4.1.0"
59 61 from urllib.error import URLError, HTTPError
60 62
61 63 # =============================================================================
@@ -638,6 +640,19 @@ T = {
638 640 "deploy_rollback_fail": "No previous deployment.",
639 641 "deploy_cleanup_ok": "Removed {} old deployments.",
640 642 "deploy_cleanup_none": "No deployments to clean (minimum {}).",
643 + "snapshot_none": "No system snapshots.",
644 + "snapshot_list": "System snapshots ({}):",
645 + "snapshot_created": "Snapshot created: {}.",
646 + "snapshot_deleted": "Snapshot removed: {}.",
647 + "snapshot_not_found": "Snapshot not found: {}",
648 + "snapshot_unsupported": "Snapshots unavailable: {}",
649 + "snapshot_rollback_next": "Next boot set to snapshot: {}",
650 + "snapshot_rollback_hint": "Select this entry in the GRUB menu: {}",
651 + "staging_prepare": "Preparing {} packages in staging (system unchanged)...",
652 + "staging_failed": "Staging failed – the system was NOT modified.",
653 + "staging_commit": "All packages prepared – applying changes...",
654 + "dry_run_done": "Dry run – nothing was changed.",
655 + "dry_run_plan": "Dry run – transaction plan (no changes):",
641 656 "why_explicit": "explicitly installed",
642 657 "why_dependency": "dependency of",
643 658 "why_not_installed": "not installed",
@@ -768,6 +783,19 @@ T = {
768 783 "deploy_rollback_fail": "Brak poprzedniego deploymentu.",
769 784 "deploy_cleanup_ok": "Usunięto {} starych deploymentów.",
770 785 "deploy_cleanup_none": "Nie ma deploymentów do wyczyszczenia (minimum {}).",
786 + "snapshot_none": "Brak snapshotów systemu.",
787 + "snapshot_list": "Snapshoty systemu ({}):",
788 + "snapshot_created": "Utworzono snapshot: {}.",
789 + "snapshot_deleted": "Usunięto snapshot: {}.",
790 + "snapshot_not_found": "Nie znaleziono snapshotu: {}",
791 + "snapshot_unsupported": "Snapshoty niedostępne: {}",
792 + "snapshot_rollback_next": "Następny start ustawiono na snapshot: {}",
793 + "snapshot_rollback_hint": "Wybierz ten wpis w menu GRUB: {}",
794 + "staging_prepare": "Przygotowuję {} pakietów w stagingu (system bez zmian)...",
795 + "staging_failed": "Etap przygotowania nieudany – system NIE został zmieniony.",
796 + "staging_commit": "Wszystkie pakiety przygotowane – nakładam zmiany...",
797 + "dry_run_done": "Dry-run – nic nie zmieniono.",
798 + "dry_run_plan": "Dry-run – plan transakcji (bez zmian):",
771 799 "why_explicit": "zainstalowany jawnie",
772 800 "why_dependency": "zależność od",
773 801 "why_not_installed": "niezainstalowany",
@@ -1001,6 +1029,14 @@ DEPLOYMENTS_DIR = "/.deployments"
1001 1029 ACTIVE_LINK = "/.deployments/active"
1002 1030 DEPLOYMENTS_DB = "/var/lib/pag/deployments.json"
1003 1031
1032 +# Snapshoty systemu (CoW). Na btrfs każdy snapshot jest osobnym subwolumenem,
1033 +# więc zajmuje tylko zmienione bloki, a GRUB potrafi uruchomić system z wybranej
1034 +# migawki (rootflags=subvol=...). Na ext4/xfs nie ma snapshotów CoW – zostaje
1035 +# atomowy staging + backup nadpisywanych plików.
1036 +SNAPSHOTS_DIR = "/.pag_snapshots"
1037 +SNAPSHOTS_DB = "/var/lib/pag/snapshots.json"
1038 +GRUB_SNAPSHOT_SCRIPT = "/etc/grub.d/40_pagan_snapshots"
1039 +
1004 1040 # Ścieżki współdzielone – NIE wchodzą do deploymentu (są symlinkami do /...)
1005 1041 SHARED_PATHS = {
1006 1042 "/var", "/etc", "/home", "/root", "/tmp", "/run",
@@ -1141,6 +1177,429 @@ def _switch_deployment(deploy_dir: str) -> bool:
1141 1177 os.rename(tmp_link, ACTIVE_LINK) # atomowe na tym samym FS
1142 1178 return True
1143 1179
1180 +# =============================================================================
1181 +# SNAPSHOTY SYSTEMU (CoW – btrfs)
1182 +# =============================================================================
1183 +# Snapshot powstaje PRZED transakcją. Na btrfs to subwolumen (kilka KB
1184 +# metadanych, reszta to współdzielone bloki), więc nie kopiujemy całego
1185 +# systemu. Wpis GRUB pozwala uruchomić system z wybranej migawki.
1186 +# Na ext4/xfs nie ma CoW – instalacja nadal jest atomowa dzięki stagingowi,
1187 +# a rollback opiera się na backupie nadpisywanych plików.
1188 +
1189 +def _btrfs_bin() -> str:
1190 + """Ścieżka do btrfs (PATH bywa okrojony w chroocie/instalatorze)."""
1191 + found = shutil.which("btrfs")
1192 + if found:
1193 + return found
1194 + for cand in ("/usr/bin/btrfs", "/usr/sbin/btrfs", "/sbin/btrfs", "/bin/btrfs"):
1195 + if os.path.exists(cand):
1196 + return cand
1197 + return ""
1198 +
1199 +
1200 +def _root_fstype() -> str:
1201 + try:
1202 + r = subprocess.run(["findmnt", "-n", "-o", "FSTYPE", "/"],
1203 + capture_output=True, text=True, timeout=5)
1204 + fs = r.stdout.strip().splitlines()[0].strip() if r.stdout.strip() else ""
1205 + if fs:
1206 + return fs
1207 + except Exception:
1208 + pass
1209 + try:
1210 + r = subprocess.run(["stat", "-f", "-c", "%T", "/"],
1211 + capture_output=True, text=True, timeout=5)
1212 + return r.stdout.strip()
1213 + except Exception:
1214 + return ""
1215 +
1216 +
1217 +def _btrfs_root_path() -> str:
1218 + """Ścieżka aktywnego subwolumenu root względem top-level btrfs."""
1219 + btrfs = _btrfs_bin()
1220 + if btrfs:
1221 + try:
1222 + r = subprocess.run([btrfs, "subvolume", "show", "/"],
1223 + capture_output=True, text=True, timeout=5)
1224 + if r.returncode == 0:
1225 + for line in r.stdout.splitlines():
1226 + line = line.strip()
1227 + if line.lower().startswith("path:"):
1228 + p = line.split(":", 1)[1].strip()
1229 + if p in ("", "/"):
1230 + return "/"
1231 + return p.strip("/")
1232 + except Exception:
1233 + pass
1234 + try:
1235 + r = subprocess.run(["findmnt", "-n", "-o", "FSROOT", "/"],
1236 + capture_output=True, text=True, timeout=5)
1237 + p = r.stdout.strip()
1238 + if p and p != "/":
1239 + return p.strip("/")
1240 + except Exception:
1241 + pass
1242 + return "/"
1243 +
1244 +
1245 +def _snapshot_support() -> Tuple[bool, str]:
1246 + fs = _root_fstype()
1247 + if fs != "btrfs":
1248 + return False, (f"root jest na {fs or 'nieznanym systemie plików'} – "
1249 + f"snapshoty CoW wymagają btrfs")
1250 + if not _btrfs_bin():
1251 + return False, "brak narzędzia btrfs (zainstaluj pakiet btrfs-progs)"
1252 + return True, ""
1253 +
1254 +
1255 +def _load_snapshots() -> List[dict]:
1256 + if not os.path.exists(SNAPSHOTS_DB):
1257 + return []
1258 + try:
1259 + data = load_json(SNAPSHOTS_DB)
1260 + return data if isinstance(data, list) else []
1261 + except Exception:
1262 + return []
1263 +
1264 +
1265 +def _save_snapshots(items: List[dict]):
1266 + os.makedirs(os.path.dirname(SNAPSHOTS_DB), exist_ok=True)
1267 + save_json(SNAPSHOTS_DB, items)
1268 +
1269 +
1270 +def _snapshot_label(snap: dict) -> str:
1271 + """Czytelna etykieta GRUB (bez znaków, które psują menu)."""
1272 + pkgs = list(snap.get("packages") or [])
1273 + p = ", ".join(pkgs[:3])
1274 + if len(pkgs) > 3:
1275 + p += f" +{len(pkgs) - 3}"
1276 + base = f"Pagan Linux snapshot {snap.get('id', '?')}"
1277 + if snap.get("label"):
1278 + base += f" - {snap['label']}"
1279 + if p:
1280 + base += f" - {p}"
1281 + # GRUB: usuń apostrofy i znaki kontrolne.
1282 + return re.sub(r"[\x00-\x1f']", "", base)[:120]
1283 +
1284 +
1285 +def _root_boot_arg() -> str:
1286 + """`root=UUID=...` dla wpisu GRUB (stabilne po zmianie nazw urządzeń)."""
1287 + dev = _detect_root_device()
1288 + if not dev:
1289 + return ""
1290 + if dev.startswith(("UUID=", "PARTUUID=", "LABEL=", "PARTLABEL=")):
1291 + return f" root={dev}"
1292 + uuid = ""
1293 + try:
1294 + r = subprocess.run(["blkid", "-s", "UUID", "-o", "value", dev],
1295 + capture_output=True, text=True, timeout=5)
1296 + uuid = r.stdout.strip().splitlines()[0].strip() if r.stdout.strip() else ""
1297 + except Exception:
1298 + uuid = ""
1299 + return f" root=UUID={uuid}" if uuid else f" root={dev}"
1300 +
1301 +
1302 +def _initrd_for_kernel(boot_dir: str, kernel: str) -> str:
1303 + """Nazwa initramfs pasująca do jądra (initramfs.img / initramfs-<ver>.img…)."""
1304 + if not kernel or not os.path.isdir(boot_dir):
1305 + return ""
1306 + ver = kernel[len("vmlinuz-"):] if kernel.startswith("vmlinuz-") else ""
1307 + candidates = []
1308 + if ver:
1309 + candidates += [f"initramfs-{ver}.img", f"initrd.img-{ver}"]
1310 + candidates += ["initramfs.img", "initrd.img"]
1311 + for c in candidates:
1312 + if os.path.isfile(os.path.join(boot_dir, c)):
1313 + return c
1314 + for f in sorted(os.listdir(boot_dir)):
1315 + if f.startswith(("initramfs", "initrd")):
1316 + return f
1317 + return ""
1318 +
1319 +
1320 +def _pick_kernel_initrd(boot_dir: str) -> Tuple[str, str]:
1321 + kernels = sorted(
1322 + [f for f in os.listdir(boot_dir) if f.startswith("vmlinuz-")],
1323 + reverse=True,
1324 + ) if os.path.isdir(boot_dir) else []
1325 + if not kernels:
1326 + return "", ""
1327 + k = kernels[0]
1328 + return k, _initrd_for_kernel(boot_dir, k)
1329 +
1330 +
1331 +def _grub_snapshot_entries() -> List[str]:
1332 + """Wpisy menu GRUB dla snapshotów (dla `_update_grub_config` i grub.d)."""
1333 + snaps = _load_snapshots()
1334 + if not snaps:
1335 + return []
1336 +
1337 + root_arg = _root_boot_arg()
1338 + try:
1339 + separate_boot = os.path.isdir("/boot") and os.path.ismount("/boot")
1340 + except OSError:
1341 + separate_boot = False
1342 + bp = _boot_prefix()
1343 +
1344 + lines: List[str] = []
1345 + for snap in reversed(snaps):
1346 + path = snap.get("path") or ""
1347 + if not path or not os.path.isdir(path):
1348 + continue
1349 +
1350 + if separate_boot:
1351 + # Osobne /boot jest współdzielone: użyj jądra ZAPISANEGO przy
1352 + # tworzeniu snapshotu (o ile nadal leży w /boot), a nie zawsze
1353 + # najnowszego – nowe jądro mogło być właśnie przyczyną problemu.
1354 + kname = snap.get("kernel") or ""
1355 + if not kname or not os.path.isfile(os.path.join("/boot", kname)):
1356 + kname, _ = _pick_kernel_initrd("/boot")
1357 + iname = _initrd_for_kernel("/boot", kname) if kname else ""
1358 + kernel = f"{bp}/{kname}" if kname else ""
1359 + initrd = f"{bp}/{iname}" if iname else ""
1360 + else:
1361 + snap_boot = os.path.join(path, "boot")
1362 + kname, iname = _pick_kernel_initrd(snap_boot)
1363 + # Kopia zapasowa: jądro z bieżącego /boot (np. gdy /boot nie
1364 + # było częścią snapshotu lub jest to bardzo stara migawka).
1365 + if not kname:
1366 + kname, iname = _pick_kernel_initrd("/boot")
1367 + kernel = f"{bp}/{kname}" if kname else ""
1368 + initrd = f"{bp}/{iname}" if iname else ""
1369 + else:
1370 + kernel = f"{path}/boot/{kname}"
1371 + initrd = f"{path}/boot/{iname}" if iname else ""
1372 +
1373 + if not kernel:
1374 + continue
1375 +
1376 + subvol = snap.get("subvol") or ""
1377 + flags = f" rootflags=subvol={subvol} rootfstype=btrfs" if subvol else ""
1378 + label = _snapshot_label(snap)
1379 +
1380 + lines.append(f"menuentry '{label}' --class pagan --class gnu-linux --class os {{")
1381 + lines.append(f" linux {kernel}{root_arg}{flags} rw quiet")
1382 + if initrd:
1383 + lines.append(f" initrd {initrd}")
1384 + lines.append("}")
1385 + lines.append("")
1386 + return lines
1387 +
1388 +
1389 +def _ensure_snapshot_grub_script() -> bool:
1390 + """Instaluje /etc/grub.d/40_pagan_snapshots (integracja z grub-mkconfig)."""
1391 + if not os.path.isdir("/etc/grub.d"):
1392 + return False
1393 + # Preferuj BIEŻĄCĄ binarkę (np. testy z repo), a nie starszy /usr/bin/pag:
1394 + # stary pag nie zna `snapshot-grub` i uruchomiłby smart-search.
1395 + _self = os.path.abspath(sys.argv[0]) if sys.argv[0] else ""
1396 + exe = _self if _self and os.path.isfile(_self) else (shutil.which("pag") or "/usr/bin/pag")
1397 + if not exe or not os.path.exists(exe):
1398 + exe = "/usr/bin/pag"
1399 + quoted = exe.replace("'", "'\\''")
1400 + script = (
1401 + "#!/bin/sh\n"
1402 + "# Pagan Linux – wpisy GRUB dla snapshotów systemu (wygenerowane przez pag)\n"
1403 + "# Usuń ten plik, aby ukryć snapshoty w menu GRUB.\n"
1404 + f"PAG_BIN='{quoted}'\n"
1405 + 'if [ ! -x "$PAG_BIN" ]; then\n'
1406 + ' PAG_BIN="$(command -v pag 2>/dev/null || true)"\n'
1407 + "fi\n"
1408 + '[ -x "$PAG_BIN" ] || exit 0\n'
1409 + '# Tylko pag >= 4.1 zna komendę snapshot-grub (starszy zrobiłby\n'
1410 + '# smart-search i mógłby zawiesić grub-mkconfig na sieci).\n'
1411 + 'case "$("$PAG_BIN" --version 2>/dev/null)" in\n'
1412 + ' "pag 4."[1-9]*|"pag "[5-9]*|"pag "[1-9][0-9]*) ;;\n'
1413 + ' *) exit 0 ;;\n'
1414 + 'esac\n'
1415 + 'exec "$PAG_BIN" snapshot-grub\n'
1416 + )
1417 + try:
1418 + with open(GRUB_SNAPSHOT_SCRIPT, "w", encoding="utf-8") as fh:
1419 + fh.write(script)
1420 + os.chmod(GRUB_SNAPSHOT_SCRIPT, 0o755)
1421 + return True
1422 + except OSError:
1423 + return False
1424 +
1425 +
1426 +def _create_system_snapshot(packages: List[str], action: str,
1427 + label: str = "") -> Optional[dict]:
1428 + """Tworzy snapshot root (btrfs) i zapisuje go w bazie.
1429 +
1430 + Zwraca dict snapshotu albo None. Nie przerywa instalacji – o tym decyduje
1431 + wywołujący (tryb --snapshot wymaga sukcesu, tryb auto tylko ostrzega).
1432 + """
1433 + ok, why = _snapshot_support()
1434 + if not ok:
1435 + return None
1436 + btrfs = _btrfs_bin()
1437 + try:
1438 + os.makedirs(SNAPSHOTS_DIR, exist_ok=True)
1439 + except OSError as e:
1440 + print(f" ⚠ Nie mogę utworzyć {SNAPSHOTS_DIR}: {e}", file=sys.stderr)
1441 + return None
1442 +
1443 + base_id = datetime.now().strftime("%Y%m%dT%H%M%S")
1444 + snap_id = base_id
1445 + n = 1
1446 + while os.path.lexists(os.path.join(SNAPSHOTS_DIR, snap_id)):
1447 + snap_id = f"{base_id}-{n}"
1448 + n += 1
1449 + snap_path = os.path.join(SNAPSHOTS_DIR, snap_id)
1450 +
1451 + try:
1452 + r = subprocess.run([btrfs, "subvolume", "snapshot", "/", snap_path],
1453 + capture_output=True, text=True, timeout=600)
1454 + except Exception as e:
1455 + print(f" ⚠ Nie udało się utworzyć snapshotu: {e}", file=sys.stderr)
1456 + return None
1457 + if r.returncode != 0:
1458 + msg = (r.stderr or r.stdout or "").strip().splitlines()
1459 + print(f" ⚠ btrfs snapshot nie udał się: {msg[-1] if msg else r.returncode}",
1460 + file=sys.stderr)
1461 + return None
1462 +
1463 + rootp = _btrfs_root_path()
1464 + if rootp in ("", "/"):
1465 + subvol = f"/.pag_snapshots/{snap_id}"
1466 + else:
1467 + subvol = f"{rootp}/.pag_snapshots/{snap_id}"
1468 +
1469 + # Zapamiętaj jądro/initramfs z chwili snapshotu – przy osobnym /boot
1470 + # dzięki temu uruchomimy migawkę ze STARYM (działającym) jądrem.
1471 + _kn, _ir = _pick_kernel_initrd("/boot")
1472 + snap = {
1473 + "id": snap_id,
1474 + "path": snap_path,
1475 + "subvol": subvol,
1476 + "created": datetime.now().isoformat(),
1477 + "action": action,
1478 + "label": label,
1479 + "packages": list(packages)[:100],
1480 + "kernel": _kn,
1481 + "initrd": _ir,
1482 + }
1483 + items = _load_snapshots()
1484 + items.append(snap)
1485 + _save_snapshots(items)
1486 + _ensure_snapshot_grub_script()
1487 + print(f" 📸 Snapshot systemu: {snap_id} (subvol={subvol})")
1488 + return snap
1489 +
1490 +
1491 +def _find_snapshot(snap_id: str) -> Optional[dict]:
1492 + items = _load_snapshots()
1493 + if not snap_id:
1494 + return items[-1] if items else None
1495 + for s in items:
1496 + if s.get("id") == snap_id:
1497 + return s
1498 + for s in items:
1499 + if str(s.get("id", "")).startswith(snap_id):
1500 + return s
1501 + return None
1502 +
1503 +
1504 +def cmd_snapshot_list():
1505 + items = _load_snapshots()
1506 + if not items:
1507 + print(_("snapshot_none"))
1508 + return 0
1509 + print(_("snapshot_list", len(items)))
1510 + for s in reversed(items):
1511 + pkgs = list(s.get("packages") or [])
1512 + listed = ", ".join(pkgs[:4])
1513 + if len(pkgs) > 4:
1514 + listed += f" +{len(pkgs) - 4}"
1515 + print(f" {s.get('id', '?')} [{s.get('action', '')}]")
1516 + if listed:
1517 + print(f" {listed}")
1518 + print(f" {s.get('created', '')}")
1519 + print(f" {s.get('path', '')}")
1520 + return 0
1521 +
1522 +
1523 +def cmd_snapshot_grub():
1524 + """Wypisuje menuentry dla grub-mkconfig (wywoływane z 40_pagan_snapshots)."""
1525 + for line in _grub_snapshot_entries():
1526 + print(line)
1527 + return 0
1528 +
1529 +
1530 +def cmd_snapshot_create(label: str = ""):
1531 + ok, why = _snapshot_support()
1532 + if not ok:
1533 + print(f" ❌ {_('snapshot_unsupported', why)}")
1534 + return 1
1535 + snap = _create_system_snapshot([], "manual", label=label)
1536 + if not snap:
1537 + return 1
1538 + _ensure_snapshot_grub_script()
1539 + _refresh_bootloader()
1540 + print(f" ✅ {_('snapshot_created', snap['id'])}")
1541 + return 0
1542 +
1543 +
1544 +def cmd_snapshot_delete(snap_id: str):
1545 + snap = _find_snapshot(snap_id)
1546 + if not snap:
1547 + print(f" ❌ {_('snapshot_not_found', snap_id)}")
1548 + return 1
1549 + path = snap.get("path") or ""
1550 + if not path.startswith(SNAPSHOTS_DIR + "/"):
1551 + print(" ❌ Nieprawidłowa ścieżka snapshotu – odmawiam usunięcia.")
1552 + return 1
1553 + if os.path.isdir(path):
1554 + btrfs = _btrfs_bin()
1555 + if not btrfs:
1556 + print(f" ❌ {_('snapshot_unsupported', 'brak btrfs')}")
1557 + return 1
1558 + r = subprocess.run([btrfs, "subvolume", "delete", path],
1559 + capture_output=True, text=True, timeout=120)
1560 + if r.returncode != 0:
1561 + print(f" ❌ btrfs: {(r.stderr or '').strip()[:200]}")
1562 + return 1
1563 + _save_snapshots([s for s in _load_snapshots() if s.get("id") != snap.get("id")])
1564 + _refresh_bootloader()
1565 + print(f" ✅ {_('snapshot_deleted', snap.get('id', ''))}")
1566 + return 0
1567 +
1568 +
1569 +def cmd_snapshot_rollback(snap_id: str = ""):
1570 + """Ustawia snapshot jako następny start (albo pokazuje wybór w GRUB)."""
1571 + snap = _find_snapshot(snap_id)
1572 + if not snap:
1573 + print(f" ❌ {_('snapshot_not_found', snap_id or '(brak)' )}")
1574 + return 1
1575 + if not os.path.isdir(snap.get("path") or ""):
1576 + print(f" ❌ {_('snapshot_not_found', snap.get('id', ''))}")
1577 + return 1
1578 +
1579 + label = _snapshot_label(snap)
1580 + print(f" ⏪ Snapshot: {snap.get('id', '')}")
1581 + print(f" {snap.get('created', '')}")
1582 + pkgs = list(snap.get("packages") or [])
1583 + if pkgs:
1584 + print(f" {', '.join(pkgs[:8])}{' …' if len(pkgs) > 8 else ''}")
1585 + if not _ask_confirm():
1586 + return 0
1587 +
1588 + _ensure_snapshot_grub_script()
1589 + _refresh_bootloader()
1590 +
1591 + grub_reboot = shutil.which("grub-reboot") or shutil.which("grub2-reboot")
1592 + if grub_reboot:
1593 + r = subprocess.run([grub_reboot, label], capture_output=True, text=True)
1594 + if r.returncode == 0:
1595 + print(f" ✅ {_('snapshot_rollback_next', label)}")
1596 + print(" 💡 Zrestartuj system – GRUB uruchomi wybrany snapshot.")
1597 + return 0
1598 + print(f" ℹ {_('snapshot_rollback_hint', label)}")
1599 + print(" 💡 Przy starcie wybierz wpis w menu GRUB (sekcja snapshotów).")
1600 + return 0
1601 +
1602 +
1144 1603 DEFAULT_REPOS = [
1145 1604 "https://repo.paganlinux.eu/stable/",
1146 1605 ]
@@ -2325,49 +2784,118 @@ def _install_file(src: str, rel: str, data_staging: str, sums: dict,
2325 2784 return True
2326 2785
2327 2786
2328 -def _atomic_install(pkg_path: str, pkg: PackageInfo, deploy_dir: str = "",
2329 - backup_dir: str = "",
2330 - old_checksums: Optional[dict] = None) -> Tuple[bool, List[dict], List[Tuple[str, str]]]:
2331 - """
2332 - Rozpakowuje do staging area, potem atomowo przenosi pliki.
2333 - Jeśli deploy_dir podany – instaluje do deploymentu (tryb immutable).
2334 - Zwraca (success, [lista plików z SHA256], [(backup_path, dst), ...]).
2335 - """
2336 - staging = tempfile.mkdtemp(dir=STAGING_DIR, prefix=f".staging-{pkg.name}-")
2337 - # Wbudowana lista + ścieżki zadeklarowane przez recepturę (metadata.json).
2338 - priv = PRIVILEGED_PATHS | frozenset(pkg.privileged or ())
2339 - journal = []
2340 - installed_files = []
2341 - backup_journal: List[Tuple[str, str]] = []
2342 2787
2788 +def _stage_package(pkg_path: str, pkg: PackageInfo) -> Optional[dict]:
2789 + """Rozpakowuje pakiet do stagingu, NIE dotykając systemu.
2790 +
2791 + Zwraca dict: staging, data, sums, hooks. None przy błędzie.
2792 +
2793 + To pierwsza faza transakcji grupowej: najpierw przygotowujemy WSZYSTKIE
2794 + pakiety (np. całe GNOME – 50 paczek). Dopiero gdy każda się rozpakuje i
2795 + przejdzie weryfikację SHA256, przechodzimy do fazy commit. Błąd jednej
2796 + paczki nie zostawia więc systemu w połowie instalacji.
2797 + """
2798 + staging = tempfile.mkdtemp(dir=STAGING_DIR, prefix=f".stage-{pkg.name}-")
2343 2799 try:
2344 - # Rozpakuj .pkg.tar.xz → staging (bezpieczne – ochrona Directory Traversal)
2345 2800 with tarfile.open(pkg_path, "r:xz") as tf:
2346 2801 _safe_extractall(tf, staging)
2347 2802
2348 2803 data_tar = os.path.join(staging, "data.tar.xz")
2349 2804 if not os.path.exists(data_tar):
2350 - shutil.rmtree(staging, ignore_errors=True)
2351 - return False, [], backup_journal
2805 + raise RuntimeError("brak data.tar.xz w pakiecie")
2352 2806
2353 - # Rozpakuj data.tar.xz → staging/data (bezpieczne – ochrona Directory Traversal)
2354 2807 data_staging = os.path.join(staging, "data")
2355 2808 os.makedirs(data_staging, exist_ok=True)
2809 + priv = PRIVILEGED_PATHS | frozenset(pkg.privileged or ())
2356 2810 with tarfile.open(data_tar, "r:xz") as tf:
2357 2811 _safe_extractall(tf, data_staging, privileged=priv)
2358 2812
2359 - # Wczytaj sums.json
2360 2813 sums_path = os.path.join(data_staging, "sums.json")
2361 2814 sums = json.load(open(sums_path)) if os.path.exists(sums_path) else {}
2362 2815
2816 + # Weryfikacja SHA256 JUŻ w stagingu – uszkodzona paczka nie dojdzie
2817 + # do fazy commit, więc nie zdąży nadpisać żadnego pliku w systemie.
2818 + _bad: List[str] = []
2819 + for _root, _dirs, _files in os.walk(data_staging):
2820 + for _name in list(_dirs) + _files:
2821 + if _name == "sums.json":
2822 + continue
2823 + _fp = os.path.join(_root, _name)
2824 + _rel = "/" + os.path.relpath(_fp, data_staging)
2825 + _expected = sums.get(_rel, "")
2826 + if not _expected:
2827 + continue
2828 + try:
2829 + if os.path.islink(_fp):
2830 + _actual = hashlib.sha256(
2831 + os.readlink(_fp).encode()).hexdigest()
2832 + elif os.path.isfile(_fp):
2833 + _actual = _sha256_file(_fp)
2834 + else:
2835 + continue
2836 + except OSError:
2837 + _actual = ""
2838 + if _actual != _expected:
2839 + _bad.append(_rel)
2840 + if len(_bad) >= 5:
2841 + break
2842 + if len(_bad) >= 5:
2843 + break
2844 + if _bad:
2845 + raise RuntimeError(
2846 + "niezgodność SHA256: " + ", ".join(_bad[:5]))
2847 +
2848 + return {
2849 + "staging": staging,
2850 + "data": data_staging,
2851 + "sums": sums,
2852 + "hooks": os.path.join(staging, "hooks"),
2853 + }
2854 + except Exception as e:
2855 + shutil.rmtree(staging, ignore_errors=True)
2856 + print(f" ❌ {pkg.name}: etap przygotowania nieudany ({e})")
2857 + return None
2858 +
2859 +
2860 +def _discard_staged(staged: Optional[dict]):
2861 + """Usuwa katalog stagingu przygotowanego pakietu (bez zmian w systemie)."""
2862 + if staged and staged.get("staging"):
2863 + shutil.rmtree(staged["staging"], ignore_errors=True)
2864 +
2865 +
2866 +def _apply_staged_package(staged: dict, pkg: PackageInfo, deploy_dir: str = "",
2867 + backup_dir: str = "",
2868 + old_checksums: Optional[dict] = None
2869 + ) -> Tuple[bool, List[dict], List[Tuple[str, str]]]:
2870 + """Faza commit: przenosi przygotowany pakiet do systemu.
2871 +
2872 + Hooki pre/post-install uruchamiane są tutaj – dopiero po tym, jak cała
2873 + grupa pakietów została poprawnie rozpakowana w stagingu.
2874 + """
2875 + staging = staged["staging"]
2876 + data_staging = staged["data"]
2877 + sums = staged["sums"]
2878 + hooks_dir = staged["hooks"]
2879 + priv = PRIVILEGED_PATHS | frozenset(pkg.privileged or ())
2880 + journal: List[tuple] = []
2881 + installed_files: List[dict] = []
2882 + backup_journal: List[Tuple[str, str]] = []
2883 +
2884 + try:
2363 2885 # Hook pre-install (przed przeniesieniem plików do systemu)
2364 - _run_hook(os.path.join(staging, "hooks"), "pre-install", pkg)
2886 + _run_hook(hooks_dir, "pre-install", pkg)
2365 2887
2366 2888 # Przenieś pliki: staging/data/* → /
2367 2889 for root, dirs, files in os.walk(data_staging):
2890 + # Symlink do katalogu (np. /lib → usr/lib) os.walk zwraca w `dirs`.
2891 + # Nie wolno tworzyć z niego prawdziwego katalogu – przekieruj do
2892 + # pętli plików, gdzie _install_file odtworzy symlink.
2893 + for _d in list(dirs):
2894 + if os.path.islink(os.path.join(root, _d)):
2895 + dirs.remove(_d)
2896 + files.append(_d)
2897 +
2368 2898 # Odtwórz katalogi z pakietu – w tym PUSTE (np. /etc/pulse/default.pa.d).
2369 - # Pętla plików tworzy tylko rodziców instalowanych plików, przez co
2370 - # puste katalogi z data.tar.xz ginęły przy instalacji.
2371 2899 for d in dirs:
2372 2900 src_dir = os.path.join(root, d)
2373 2901 rel_dir = os.path.relpath(src_dir, data_staging)
@@ -2390,19 +2918,16 @@ def _atomic_install(pkg_path: str, pkg: PackageInfo, deploy_dir: str = "",
2390 2918 rel = os.path.relpath(src, data_staging)
2391 2919
2392 2920 ok = _install_file(src, rel, data_staging, sums,
2393 - staging, journal, installed_files, deploy_dir,
2394 - backup_dir, backup_journal,
2395 - old_checksums=old_checksums,
2396 - privileged=priv)
2921 + staging, journal, installed_files, deploy_dir,
2922 + backup_dir, backup_journal,
2923 + old_checksums=old_checksums,
2924 + privileged=priv)
2397 2925 if not ok:
2398 2926 # Cofnij wszystkie operacje
2399 2927 _rollback_journal(journal, staging)
2400 2928 return False, [], backup_journal
2401 2929
2402 2930 # Odbuduj cache ikon GTK dla motywów dotkniętych instalacją.
2403 - # Bez icon-theme.cache aplikacje GTK nie widzą ikon mimo obecności
2404 - # motywu (np. /usr/share/icons/Papirus). Pomijamy, gdy narzędzie
2405 - # nie jest zainstalowane.
2406 2931 _icon_dirs = set()
2407 2932 for f in installed_files:
2408 2933 fp = f.get("path", "") or ""
@@ -2423,7 +2948,6 @@ def _atomic_install(pkg_path: str, pkg: PackageInfo, deploy_dir: str = "",
2423 2948 pass
2424 2949
2425 2950 # Uruchom hooki post-install
2426 - hooks_dir = os.path.join(staging, "hooks")
2427 2951 _run_hook(hooks_dir, "post-install", pkg)
2428 2952
2429 2953 # Zachowaj hooki na wypadek usunięcia pakietu (pre/post-remove)
@@ -2443,9 +2967,25 @@ def _atomic_install(pkg_path: str, pkg: PackageInfo, deploy_dir: str = "",
2443 2967
2444 2968 except Exception as e:
2445 2969 _rollback_journal(journal, staging)
2970 + print(f" ❌ {pkg.name}: błąd commit – {e}")
2446 2971 return False, [], backup_journal
2447 2972
2448 2973
2974 +def _atomic_install(pkg_path: str, pkg: PackageInfo, deploy_dir: str = "",
2975 + backup_dir: str = "",
2976 + old_checksums: Optional[dict] = None
2977 + ) -> Tuple[bool, List[dict], List[Tuple[str, str]]]:
2978 + """Instaluje pojedynczy pakiet dwufazowo: staging → commit.
2979 +
2980 + Zachowane jako publiczny wrapper dla instalacji pojedynczych plików
2981 + lokalnych; transakcja grupowa w cmd_install przygotowuje staging dla
2982 + całej grupy i wywołuje _apply_staged_package bezpośrednio.
2983 + """
2984 + staged = _stage_package(pkg_path, pkg)
2985 + if not staged:
2986 + return False, [], []
2987 + return _apply_staged_package(staged, pkg, deploy_dir, backup_dir, old_checksums)
2988 +
2449 2989 def _refresh_dynamic_linker_cache(deploy_dir: str = "") -> bool:
2450 2990 """Odświeża cache ld.so po udanej instalacji pakietów."""
2451 2991 ldconfig = shutil.which("ldconfig")
@@ -2832,7 +3372,7 @@ def _run_hook(hooks_dir: str, hook_name: str, pkg: PackageInfo) -> bool:
2832 3372 # =============================================================================
2833 3373
2834 3374 def _record_transaction(action, packages, success, snapshot, file_journal=None, hooks=None,
2835 - upgrade_backups=None, upgrade_backup_root=""):
3375 + upgrade_backups=None, upgrade_backup_root="", snapshot_id=""):
2836 3376 history = load_json(HISTORY_FILE) if os.path.exists(HISTORY_FILE) else []
2837 3377 # Rejestr wykonanych hooków – informacja o tym, że uruchomiono kod pakietu
2838 3378 # jako root. Trafia do historii, by dało się później sprawdzić, co się działo.
@@ -2845,6 +3385,10 @@ def _record_transaction(action, packages, success, snapshot, file_journal=None,
2845 3385 "file_journal": file_journal, # lista plików do wycofania
2846 3386 "hooks": executed_hooks, # wykonane hooki (pre/post-install/remove)
2847 3387 }
3388 + if snapshot_id:
3389 + # Snapshot systemu (btrfs) z chwili PRZED transakcją – można z niego
3390 + # uruchomić system z menu GRUB albo podejrzeć `pag snapshot-list`.
3391 + entry["snapshot_id"] = snapshot_id
2848 3392 if upgrade_backups:
2849 3393 entry["upgrade_backups"] = upgrade_backups # {dst: backup_path}
2850 3394 entry["upgrade_backup_root"] = upgrade_backup_root
@@ -2946,35 +3490,52 @@ def cmd_rollback():
2946 3490 # =============================================================================
2947 3491
2948 3492 def _install_local_pkg_files(paths, install_succeeded):
2949 - """Instaluje lokalne pliki .pkg.tar.xz (bez repozytorium).
2950 - Zgodnie z _atomic_install każdy plik jest instalowany atomowo.
2951 - Zwraca (failed_count, installed_files)."""
3493 + """Instaluje lokalne pliki .pag (bez repozytorium).
3494 +
3495 + Najpierw przygotowuje WSZYSTKIE paczki w stagingu, potem je nakłada.
3496 + Dzięki temu uszkodzony plik w środku grupy nie zostawia systemu
3497 + w połowie instalacji. Zwraca (failed_count, installed_files).
3498 + """
2952 3499 failed = 0
2953 - all_files = []
3500 + prepared = []
2954 3501 for p in paths:
2955 3502 p = os.path.abspath(p)
2956 3503 if not os.path.isfile(p):
2957 3504 print(f" ❌ Nie znaleziono pakietu: {p}")
2958 3505 failed += 1
2959 - continue
3506 + break
2960 3507 if not _verify_local_pkg_signature(p):
2961 3508 failed += 1
2962 - continue
3509 + break
2963 3510 try:
2964 3511 with tarfile.open(p, "r:xz") as tf:
2965 3512 meta = tf.extractfile("metadata.json")
2966 3513 if meta is None:
2967 3514 print(f" ❌ {p}: brak metadata.json")
2968 3515 failed += 1
2969 - continue
3516 + break
2970 3517 data = json.loads(meta.read())
2971 3518 except Exception as e:
2972 3519 print(f" ❌ {p}: nie udało się odczytać pakietu ({e})")
2973 3520 failed += 1
2974 - continue
3521 + break
2975 3522 pkg = PackageInfo(data, repo="local")
3523 + staged = _stage_package(p, pkg)
3524 + if not staged:
3525 + failed += 1
3526 + break
3527 + prepared.append((pkg, staged))
3528 +
3529 + if failed:
3530 + for _pkg, _st in prepared:
3531 + _discard_staged(_st)
3532 + print(" ↩ Etap przygotowania nieudany – system NIE został zmieniony.")
3533 + return failed, []
3534 +
3535 + all_files = []
3536 + for pkg, staged in prepared:
2976 3537 print(f" ↓ {pkg.name}-{pkg.version} (lokalny) ... ", end="", flush=True)
2977 - ok, files, _ = _atomic_install(p, pkg)
3538 + ok, files, _ = _apply_staged_package(staged, pkg)
2978 3539 if ok:
2979 3540 install_succeeded(pkg, files)
2980 3541 all_files.extend(f["path"] for f in files)
@@ -3155,6 +3716,18 @@ def cmd_install(package_names, as_dep=False, upgrade=False):
3155 3716 if not _ask_confirm():
3156 3717 print(_("cancelled")); return 0
3157 3718
3719 + # `--dry-run`: pokaż plan i wyjdź. Nic nie jest pobierane, rozpakowywane
3720 + # ani zmieniane – bezpieczne sprawdzenie, co zrobiłaby transakcja.
3721 + if os.environ.get("PAG_DRY_RUN", "") == "1":
3722 + print(f"\n 🧪 {_('dry_run_plan')}")
3723 + for _n in to_install:
3724 + _p = repo_pkgs.get(_n)
3725 + if _p:
3726 + _mark = " [upgrade]" if _n in installed_db else f" [{_('new')}]"
3727 + print(f" {_n}-{_p.version}{_mark}")
3728 + print(f" {_('dry_run_done')}")
3729 + return 0
3730 +
3158 3731 snapshot = copy.deepcopy(installed_db)
3159 3732 all_installed_files = []
3160 3733 failed = []
@@ -3226,6 +3799,65 @@ def cmd_install(package_names, as_dep=False, upgrade=False):
3226 3799 print(" ↩ Przerwano PRZED instalacją – żadna paczka nie została zmieniona.")
3227 3800 return 1
3228 3801
3802 + # --- Snapshot systemu PRZED transakcją (btrfs CoW) ---
3803 + # Tworzymy go PO pobraniu i weryfikacji paczek, ale PRZED rozpakowaniem
3804 + # czegokolwiek do systemu. Domyślnie `auto`: tylko na btrfs. `--snapshot`
3805 + # wymusza migawkę (i przerywa, gdy się nie uda), `--no-snapshot` wyłącza.
3806 + snapshot_mode = (os.environ.get("PAG_SNAPSHOT") or "auto").strip().lower()
3807 + sys_snap: Optional[dict] = None
3808 + if to_install and snapshot_mode not in ("never", "no", "0", "off"):
3809 + _snap_ok, _snap_why = _snapshot_support()
3810 + if _snap_ok:
3811 + sys_snap = _create_system_snapshot(
3812 + to_install, "upgrade" if upgrade else "install")
3813 + if sys_snap:
3814 + _refresh_bootloader()
3815 + elif snapshot_mode in ("always", "require", "1", "yes"):
3816 + print(" ❌ Nie udało się utworzyć snapshotu (tryb --snapshot) – przerywam.")
3817 + return 1
3818 + elif snapshot_mode in ("always", "require", "1", "yes"):
3819 + print(f" ❌ {_('snapshot_unsupported', _snap_why)}")
3820 + return 1
3821 + else:
3822 + print(f" ℹ {_('snapshot_unsupported', _snap_why)}")
3823 +
3824 + # --- Faza 1c: PRZYGOTOWANIE CAŁEJ GRUPY W STAGINGU ---
3825 + # Rozpakowujemy WSZYSTKIE pakiety do `/.pag_staging/.stage-*`, zanim
3826 + # dotkniemy systemu. Jeśli jedna z 50 paczek (np. GNOME) jest uszkodzona,
3827 + # transakcja kończy się tutaj – na dysku nie ma żadnych zmian.
3828 + atomic = os.environ.get("PAG_ATOMIC", "1") != "0"
3829 + staged_pkgs: List[Tuple[str, PackageInfo, Optional[dict]]] = []
3830 + if atomic and to_install:
3831 + print(f"\n 🧰 {_('staging_prepare', len(to_install))}")
3832 + _sbar = _StepBar(len(to_install), icon="🧰 ", width=25)
3833 + _stage_failed: List[str] = []
3834 + for _si, _name in enumerate(to_install, 1):
3835 + _pkg = repo_pkgs.get(_name)
3836 + _pp = verified.get(_name)
3837 + if not _pkg or not _pp:
3838 + _stage_failed.append(_name)
3839 + break
3840 + _sbar.step(_si, f"{_name}-{_pkg.version}")
3841 + _st = _stage_package(_pp, _pkg)
3842 + if not _st:
3843 + _stage_failed.append(_name)
3844 + break
3845 + staged_pkgs.append((_name, _pkg, _st))
3846 + _sbar.end()
3847 + if _stage_failed:
3848 + for _n, _p, _st in staged_pkgs:
3849 + _discard_staged(_st)
3850 + print(f" ↩ {_('staging_failed')}")
3851 + if backup_root:
3852 + shutil.rmtree(backup_root, ignore_errors=True)
3853 + _record_transaction("upgrade" if upgrade else "install", to_install, False,
3854 + snapshot,
3855 + snapshot_id=sys_snap["id"] if sys_snap else "")
3856 + return 1
3857 + print(f" ✅ {_('staging_commit')}")
3858 + elif to_install:
3859 + staged_pkgs = [(n, repo_pkgs[n], None) for n in to_install]
3860 +
3229 3861 # --- Faza 2: Instalacja – JEDNA nadpisywana linia postępu (jak przy
3230 3862 # pobieraniu), bez ściany tekstu na każdy pakiet. W trybie
3231 3863 # nieinteraktywnym (logi, netinstall instalatora) wypisujemy linię na
@@ -3243,37 +3875,39 @@ def cmd_install(package_names, as_dep=False, upgrade=False):
3243 3875 def _bar_end() -> None:
3244 3876 _pbar.end()
3245 3877
3246 - _pkg_i = 0
3247 - for name in to_install:
3248 - pkg = repo_pkgs.get(name)
3878 + for _pkg_i, (name, pkg, _staged) in enumerate(staged_pkgs, 1):
3249 3879 if not pkg:
3250 3880 _bar_end()
3251 3881 print(f" ❌ {name}: {_('not_found')}")
3252 3882 failed.append(name)
3253 3883 break
3254 3884
3255 - _pkg_i += 1
3256 3885 _bar_draw(_pkg_i, f"{name}-{pkg.version}")
3257 3886
3258 - # Ścieżka pobrana i ZWERYFIKOWANA w fazie 1b – PRZED jakąkolwiek
3259 - # instalacją (patrz komentarz przy fazie 1b). Dzięki temu podmiana
3260 - # biblioteki używanej przez gpg nie psuje weryfikacji pozostałych.
3261 - pkg_path = verified.get(name)
3262 - if not pkg_path:
3263 - _bar_end()
3264 - print(f" ❌ {name}: {_('download_fail')}")
3265 - failed.append(name)
3266 - break # przerwij transakcję
3267 -
3268 3887 # Przed instalacją zapamiętaj pliki starej wersji (potrzebne w upgrade)
3269 3888 old_files = _db_get_package_files(name) if name in installed_db else []
3270 3889 # Stare sumy SHA256 – do wykrycia zmian użytkownika w plikach /etc (.pacnew)
3271 3890 old_checksums = _db_get_package_checksums(name) if name in installed_db else None
3272 3891
3273 - # Atomowa instalacja (w upgrade backupuje nadpisywane pliki)
3274 - ok, files, backup_j = _atomic_install(pkg_path, pkg, deploy_dir,
3275 - backup_dir=backup_root,
3276 - old_checksums=old_checksums)
3892 + # Commit przygotowanego pakietu (w upgrade backupuje nadpisywane pliki).
3893 + # Tryb `PAG_ATOMIC=0` zachowuje starą ścieżkę pojedynczą (staging per pakiet).
3894 + if _staged is not None:
3895 + ok, files, backup_j = _apply_staged_package(
3896 + _staged, pkg, deploy_dir,
3897 + backup_dir=backup_root,
3898 + old_checksums=old_checksums)
3899 + else:
3900 + # Ścieżka pobrana i ZWERYFIKOWANA w fazie 1b.
3901 + pkg_path = verified.get(name)
3902 + if not pkg_path:
3903 + _bar_end()
3904 + print(f" ❌ {name}: {_('download_fail')}")
3905 + failed.append(name)
3906 + break # przerwij transakcję
3907 + ok, files, backup_j = _atomic_install(
3908 + pkg_path, pkg, deploy_dir,
3909 + backup_dir=backup_root,
3910 + old_checksums=old_checksums)
3277 3911 if ok:
3278 3912 installed_db[name] = {
3279 3913 "version": pkg.version, "release": pkg.release, "description": pkg.description,
@@ -3313,11 +3947,15 @@ def cmd_install(package_names, as_dep=False, upgrade=False):
3313 3947 if failed:
3314 3948 _bar_end()
3315 3949 print(f"\n ↩ Cofanie transakcji ({len(failed)} błędów)...")
3950 + for _n, _p, _st in staged_pkgs:
3951 + _discard_staged(_st)
3316 3952 _rollback_transaction(installed_db, snapshot, all_installed_files,
3317 3953 deploy_dir, immutable, backups=all_backups)
3318 3954 if backup_root:
3319 3955 shutil.rmtree(backup_root, ignore_errors=True)
3320 - _record_transaction("upgrade" if upgrade else "install", to_install, False, snapshot)
3956 + _record_transaction("upgrade" if upgrade else "install", to_install, False,
3957 + snapshot,
3958 + snapshot_id=sys_snap["id"] if sys_snap else "")
3321 3959 return 1
3322 3960
3323 3961 save_json(INSTALLED_DB, installed_db)
@@ -3335,7 +3973,8 @@ def cmd_install(package_names, as_dep=False, upgrade=False):
3335 3973 _record_transaction("upgrade" if upgrade else "install", to_install, True, snapshot,
3336 3974 file_journal=all_installed_files,
3337 3975 upgrade_backups={dst: bp for bp, dst in all_backups} if all_backups else None,
3338 - upgrade_backup_root=backup_root)
3976 + upgrade_backup_root=backup_root,
3977 + snapshot_id=sys_snap["id"] if sys_snap else "")
3339 3978
3340 3979 # Zachowaj backupy bieżącej transakcji (dla `pag rollback`), usuń starsze.
3341 3980 if backup_root:
@@ -3361,6 +4000,11 @@ def cmd_install(package_names, as_dep=False, upgrade=False):
3361 4000 # nie może: trzymany lock PAG-a). Bez tego menu zostaje przy starym jądrze.
3362 4001 if any(_is_kernel_package(_n) for _n in to_install):
3363 4002 _post_kernel_hooks()
4003 + elif sys_snap:
4004 + # Snapshot istnieje, ale nie było zmiany jądra – odśwież menu GRUB,
4005 + # żeby wpis migawki był widoczny przy najbliższym starcie.
4006 + _ensure_snapshot_grub_script()
4007 + _refresh_bootloader()
3364 4008
3365 4009 print(f"\n✅ {_('installed', len(to_install))} ({(time.time()-t0):.0f}s)")
3366 4010 return 0
@@ -4330,18 +4974,31 @@ def cmd_repair(dry_run=False):
4330 4974 return 0
4331 4975 if not _ask_confirm():
4332 4976 print(_("cancelled")); return 0
4977 + # Jedna migawka na całą naprawę – nie tworzymy snapshotu per pakiet.
4978 + _snap_ok, _ = _snapshot_support()
4979 + if _snap_ok:
4980 + _create_system_snapshot(list(missing), "repair")
4981 + _refresh_bootloader()
4982 + _prev_snap = os.environ.get("PAG_SNAPSHOT")
4983 + os.environ["PAG_SNAPSHOT"] = "never"
4333 4984 failed = []
4334 - for n in sorted(missing, key=lambda x: (-missing[x], x)):
4335 - print(f"\n🔧 repair: {n}")
4336 - try:
4337 - rc = cmd_install([n], upgrade=True)
4338 - except SystemExit as e:
4339 - rc = e.code
4340 - except Exception as e:
4341 - print(f" ❌ {n}: {e}")
4342 - rc = 1
4343 - if rc:
4344 - failed.append(n)
4985 + try:
4986 + for n in sorted(missing, key=lambda x: (-missing[x], x)):
4987 + print(f"\n🔧 repair: {n}")
4988 + try:
4989 + rc = cmd_install([n], upgrade=True)
4990 + except SystemExit as e:
4991 + rc = e.code
4992 + except Exception as e:
4993 + print(f" ❌ {n}: {e}")
4994 + rc = 1
4995 + if rc:
4996 + failed.append(n)
4997 + finally:
4998 + if _prev_snap is None:
4999 + os.environ.pop("PAG_SNAPSHOT", None)
5000 + else:
5001 + os.environ["PAG_SNAPSHOT"] = _prev_snap
4345 5002 print()
4346 5003 ok = len(missing) - len(failed)
4347 5004 if failed:
@@ -5786,6 +6443,12 @@ def _update_grub_config():
5786 6443 lines.append("")
5787 6444 entry_num += 1
5788 6445
6446 + # Snapshoty systemu (btrfs) – każdy jako osobny wpis do uruchomienia.
6447 + _snap_lines = _grub_snapshot_entries()
6448 + if _snap_lines:
6449 + lines.append("# --- Snapshoty systemu (CoW) ---")
6450 + lines.extend(_snap_lines)
6451 +
5789 6452 # Wpis fallback: zwykły root (gdyby wszystko padło).
5790 6453 # Uwaga: GRUB NIE rozwija globów – trzeba podać KONKRETNY plik jądra
5791 6454 # (wcześniejsze `linux /boot/vmlinuz-*` było niepoprawne).
@@ -5798,9 +6461,11 @@ def _update_grub_config():
5798 6461 lines.append("menuentry 'Pagan Linux – fallback (zwykły root)' {")
5799 6462 if fallback_kernels:
5800 6463 lines.append(f" linux {_bp}/{fallback_kernels[0]}{root_arg} rw quiet")
6464 + _fi = _initrd_for_kernel("/boot", fallback_kernels[0])
6465 + if _fi:
6466 + lines.append(f" initrd {_bp}/{_fi}")
5801 6467 else:
5802 6468 lines.append(" # Brak jądra w /boot")
5803 - lines.append(f" initrd {_bp}/initramfs.img")
5804 6469 lines.append("}")
5805 6470 lines.append("")
5806 6471
@@ -5881,10 +6546,13 @@ def _detect_root_device() -> str:
5881 6546
5882 6547
5883 6548 def cmd_grub_update():
5884 - """Ręcznie regeneruje konfigurację GRUB (wpisy dla deploymentów)."""
6549 + """Ręcznie regeneruje konfigurację GRUB (deploymenty + snapshoty)."""
5885 6550 ensure_dirs()
5886 6551 print("📋 Aktualizacja konfiguracji GRUB...")
5887 - _update_grub_config()
6552 + _ensure_snapshot_grub_script()
6553 + # Deploymenty mają własny generator; zwykły system – grub-mkconfig,
6554 + # który uruchomi /etc/grub.d/40_pagan_snapshots i zachowa pozostałe wpisy.
6555 + _refresh_bootloader()
5888 6556 print("✅ GRUB zaktualizowany.")
5889 6557 return 0
5890 6558
@@ -6411,6 +7079,12 @@ FLATPAK:
6411 7079 pag flatpak update Update all flatpaks
6412 7080 pag flatpak info <id> Show flatpak details
6413 7081
7082 +SNAPSHOTS (btrfs CoW):
7083 + pag snapshot-list List system snapshots
7084 + pag snapshot-create [label] Create a snapshot now
7085 + pag snapshot-rollback [id] Start from snapshot at next boot (GRUB)
7086 + pag snapshot-delete <id> Delete a snapshot
7087 +
6414 7088 IMMUTABLE OS (PAG_IMMUTABLE=1):
6415 7089 pag deploy-list List all deployments
6416 7090 pag deploy-rollback Switch to previous deployment
@@ -6472,6 +7146,12 @@ FLATPAK:
6472 7146 pag flatpak update Aktualizuj wszystkie
6473 7147 pag flatpak info <id> Szczegóły flatpaka
6474 7148
7149 +SNAPSHOTY (btrfs CoW):
7150 + pag snapshot-list Lista snapshotów systemu
7151 + pag snapshot-create [opis] Utwórz snapshot teraz
7152 + pag snapshot-rollback [id] Uruchom snapshot przy następnym starcie (GRUB)
7153 + pag snapshot-delete <id> Usuń snapshot
7154 +
6475 7155 IMMUTABLE OS (PAG_IMMUTABLE=1):
6476 7156 pag deploy-list Lista wdrożeń
6477 7157 pag deploy-rollback Przełącz na poprzednie wdrożenie
@@ -6553,6 +7233,9 @@ def main():
6553 7233 "flatpak-info": lambda: cmd_flatpak_info(args[0]) if args else print("Usage: pag flatpak-info <id>"),
6554 7234 "deploy-list": cmd_deploy_list,
6555 7235 "deploy": cmd_deploy_list,
7236 + "snapshot-list": cmd_snapshot_list,
7237 + "snapshots": cmd_snapshot_list,
7238 + "snapshot-grub": cmd_snapshot_grub,
6556 7239 "sbom": lambda: cmd_sbom(args),
6557 7240 }
6558 7241
@@ -6573,6 +7256,7 @@ def main():
6573 7256 "self-update",
6574 7257 "flatpak", "flatpak-install", "flatpak-remove", "flatpak-update",
6575 7258 "deploy-rollback", "deploy-cleanup", "initramfs-update", "grub-update",
7259 + "snapshot-create", "snapshot-delete", "snapshot-rollback",
6576 7260 "base", "base-adopt", "base-register",
6577 7261 "repair",
6578 7262 }
@@ -6588,11 +7272,22 @@ def main():
6588 7272 sys.exit(1)
6589 7273 sys.exit(_smart_search(" ".join([cmd] + args)) or 0)
6590 7274
6591 - # Obsługa flag globalnych (-y/--yes)
7275 + # Obsługa flag globalnych (-y/--yes oraz transakcji/snapshotów)
6592 7276 global_args = []
6593 7277 for a in args:
6594 7278 if a in ("-y", "--yes"):
6595 7279 os.environ["PAG_YES"] = "1"
7280 + elif a == "--dry-run":
7281 + os.environ["PAG_DRY_RUN"] = "1"
7282 + global_args.append(a) # `repair`/`base adopt` czytają flagę
7283 + elif a == "--snapshot":
7284 + os.environ["PAG_SNAPSHOT"] = "always"
7285 + elif a == "--no-snapshot":
7286 + os.environ["PAG_SNAPSHOT"] = "never"
7287 + elif a == "--atomic":
7288 + os.environ["PAG_ATOMIC"] = "1"
7289 + elif a == "--no-atomic":
7290 + os.environ["PAG_ATOMIC"] = "0"
6596 7291 else:
6597 7292 global_args.append(a)
6598 7293 args = global_args
@@ -6609,7 +7304,9 @@ def main():
6609 7304 _recover_interrupted_transactions()
6610 7305 WRITE_COMMANDS = {
6611 7306 "install": lambda: cmd_install(
6612 - [a for a in args if a not in ("-f", "--force", "--")],
7307 + [a for a in args if a not in (
7308 + "-f", "--force", "--dry-run", "--snapshot", "--no-snapshot",
7309 + "--atomic", "--no-atomic", "--")],
6613 7310 upgrade=("-f" in args or "--force" in args)),
6614 7311 "remove": lambda: cmd_remove(args),
6615 7312 "update": lambda: cmd_update(do_upgrade=True),
@@ -6635,6 +7332,12 @@ def main():
6635 7332 "flatpak-update": cmd_flatpak_update,
6636 7333 "deploy-rollback": cmd_deploy_rollback,
6637 7334 "deploy-cleanup": lambda: cmd_deploy_cleanup(int(args[0]) if args else 3),
7335 + "snapshot-create": lambda: cmd_snapshot_create(" ".join(
7336 + a for a in args if not a.startswith("-"))),
7337 + "snapshot-delete": lambda: cmd_snapshot_delete(args[0]) if args else print(
7338 + "Usage: pag snapshot-delete <id>"),
7339 + "snapshot-rollback": lambda: cmd_snapshot_rollback(
7340 + args[0] if args else ""),
6638 7341 "initramfs-update": cmd_initramfs_update,
6639 7342 "grub-update": cmd_grub_update,
6640 7343 "base": lambda: cmd_base_register(args) if (args and args[0] == "register") else cmd_base_adopt(args),
@@ -41,6 +41,8 @@
41 41 "download_fail": "download failed",
42 42 "downloaded": "Downloaded {} to cache ({:.2f} MB).",
43 43 "downloading": "Downloading",
44 + "dry_run_done": "Dry run – nothing was changed.",
45 + "dry_run_plan": "Dry run – transaction plan (no changes):",
44 46 "flatpak_adding": "Adding Flathub remote...",
45 47 "flatpak_found": "Found {} results:",
46 48 "flatpak_info_branch": "Branch",
@@ -86,6 +88,8 @@
86 88 "pkg_not_found": "Package not found: {} (not in any repo)",
87 89 "provides_conflict": "Multiple providers for '{name}' ({providers}) – using '{chosen}'",
88 90 "provides_mapped": "{} → {} (provides)",
91 + "rdepends_none": "nothing depends on it.",
92 + "rdepends_title": "Reverse dependencies of {} ({}):",
89 93 "removing": "Removing",
90 94 "repo_added": "Added repository: {}",
91 95 "repo_exists": "Repository already exists: {}",
@@ -101,7 +105,18 @@
101 105 "sec_suid": "SUID stripped from {path}",
102 106 "sec_toobig": "Package too large: {size_mb}MB > {max_mb}MB",
103 107 "sha256_mismatch": "SHA256 mismatch",
108 + "snapshot_created": "Snapshot created: {}.",
109 + "snapshot_deleted": "Snapshot removed: {}.",
110 + "snapshot_list": "System snapshots ({}):",
111 + "snapshot_none": "No system snapshots.",
112 + "snapshot_not_found": "Snapshot not found: {}",
113 + "snapshot_rollback_hint": "Select this entry in the GRUB menu: {}",
114 + "snapshot_rollback_next": "Next boot set to snapshot: {}",
115 + "snapshot_unsupported": "Snapshots unavailable: {}",
104 116 "ssl_broken": "Python has no working ssl module (HTTPS impossible) – fix the python/openssl packages (e.g. sudo pag install -f python).",
117 + "staging_commit": "All packages prepared – applying changes...",
118 + "staging_failed": "Staging failed – the system was NOT modified.",
119 + "staging_prepare": "Preparing {} packages in staging (system unchanged)...",
105 120 "stats_base": "Base (image) managed",
106 121 "stats_cache": "Cache size",
107 122 "stats_files": "Tracked files",
@@ -115,12 +130,10 @@
115 130 "updated_done": "Index refresh complete. {} packages cached.",
116 131 "updates_available": "⚠ {} packages have updates – run: pag update",
117 132 "upgrading": "Upgrading: {} packages",
118 - "usage": "pag v4 – Pagan Linux Package Manager\n\nBASIC:\n pag install <pkg>... Install packages\n pag remove <pkg>... Remove packages\n pag update Update PACKAGES (refreshes indexes first)\n pag sync Refresh indexes + show pending package updates\n pag upgrade Update SYSTEM (packages + kernel/initramfs/GRUB)\n pag list [--installed] List available / installed\n pag search <query> Search packages\n pag info <pkg> Package details\n pag files <pkg> List package files\n pag verify [--deep] Verify integrity (--deep = SHA256 per file)\n pag clean Clear download cache\n pag stats System statistics\n pag download <pkg>... Download packages to cache (offline prep)\n\nROLLING (base baked into the image):\n pag base [status] Image packages vs. repo (what pag manages)\n pag base adopt [pkg...] Adopt base packages from the repo (--dry-run = preview)\n\nSECURITY:\n pag key-add <url|file> Import GPG key\n pag key-list List trusted keys\n pag key-remove <id> Remove key\n pag key-trust <repo> Pin repo signing key fingerprint (no TOFU)\n pag key-untrust <repo> Forget repo fingerprint (back to TOFU)\n pag key-trusted List pinned repo fingerprints\n\nADVANCED:\n pag why <pkg> Show why a package is installed\n pag autoremove Auto-remove orphaned dependencies\n pag pin <pkg> [ver] Pin package version\n pag unpin <pkg> Unpin\n pag pinned List pinned\n pag history Transaction history\n pag rollback Rollback last transaction\n pag remove-orphans Remove orphaned deps\n pag repo-add <url> [name] Add repository (drop-in /etc/pag/repos/)\n pag repo-list List repositories\n pag sbom export [fmt] SBOM manifest (spdx|cyclonedx)\n\nFLATPAK:\n pag flatpak [<query>] Search & install (smart)\n pag flatpak search <q> Search Flathub\n pag flatpak install <id> Install flatpak\n pag flatpak remove <id> Remove flatpak\n pag flatpak list List installed flatpaks\n pag flatpak update Update all flatpaks\n pag flatpak info <id> Show flatpak details\n\nIMMUTABLE OS (PAG_IMMUTABLE=1):\n pag deploy-list List all deployments\n pag deploy-rollback Switch to previous deployment\n pag deploy-cleanup [N] Remove old deployments (keep last N, default 3)\n pag initramfs-update Rebuild initramfs for current kernel/deployment\n pag grub-update Regenerate GRUB entries for all deployments\n",
133 + "usage": "pag v4 – Pagan Linux Package Manager\n\nBASIC:\n pag install <pkg>... Install packages\n pag remove <pkg>... Remove packages\n pag update Update PACKAGES (refreshes indexes first)\n pag sync Refresh indexes + show pending package updates\n pag upgrade Update SYSTEM (packages + kernel/initramfs/GRUB)\n pag list [--installed] List available / installed\n pag search <query> Search packages\n pag info <pkg> Package details\n pag files <pkg> List package files\n pag verify [--deep] Verify integrity (--deep = SHA256 per file)\n pag clean Clear download cache\n pag stats System statistics\n pag download <pkg>... Download packages to cache (offline prep)\n\nROLLING (base baked into the image):\n pag base [status] Image packages vs. repo (what pag manages)\n pag base adopt [pkg...] Adopt base packages from the repo (--dry-run = preview)\n\nSECURITY:\n pag key-add <url|file> Import GPG key\n pag key-list List trusted keys\n pag key-remove <id> Remove key\n pag key-trust <repo> Pin repo signing key fingerprint (no TOFU)\n pag key-untrust <repo> Forget repo fingerprint (back to TOFU)\n pag key-trusted List pinned repo fingerprints\n\nADVANCED:\n pag why <pkg> Show why a package is installed\n pag autoremove Auto-remove orphaned dependencies\n pag pin <pkg> [ver] Pin package version\n pag unpin <pkg> Unpin\n pag pinned List pinned\n pag history Transaction history\n pag rollback Rollback last transaction\n pag remove-orphans Remove orphaned deps\n pag repo-add <url> [name] Add repository (drop-in /etc/pag/repos/)\n pag repo-list List repositories\n pag sbom export [fmt] SBOM manifest (spdx|cyclonedx)\n\nFLATPAK:\n pag flatpak [<query>] Search & install (smart)\n pag flatpak search <q> Search Flathub\n pag flatpak install <id> Install flatpak\n pag flatpak remove <id> Remove flatpak\n pag flatpak list List installed flatpaks\n pag flatpak update Update all flatpaks\n pag flatpak info <id> Show flatpak details\n\nSNAPSHOTS (btrfs CoW):\n pag snapshot-list List system snapshots\n pag snapshot-create [label] Create a snapshot now\n pag snapshot-rollback [id] Start from snapshot at next boot (GRUB)\n pag snapshot-delete <id> Delete a snapshot\n\nIMMUTABLE OS (PAG_IMMUTABLE=1):\n pag deploy-list List all deployments\n pag deploy-rollback Switch to previous deployment\n pag deploy-cleanup [N] Remove old deployments (keep last N, default 3)\n pag initramfs-update Rebuild initramfs for current kernel/deployment\n pag grub-update Regenerate GRUB entries for all deployments\n",
119 134 "verify_errors": "{} problems found:",
120 135 "verify_ok": "All {} files intact.",
121 136 "why_dependency": "dependency of",
122 137 "why_explicit": "explicitly installed",
123 - "why_not_installed": "not installed",
124 - "rdepends_title": "Reverse dependencies of {} ({}):",
125 - "rdepends_none": "nothing depends on it."
126 -}
138 + "why_not_installed": "not installed"
139 +}
@@ -41,6 +41,8 @@
41 41 "download_fail": "błąd pobierania",
42 42 "downloaded": "Pobrano {} do cache ({:.2f} MB).",
43 43 "downloading": "Pobieranie",
44 + "dry_run_done": "Dry-run – nic nie zmieniono.",
45 + "dry_run_plan": "Dry-run – plan transakcji (bez zmian):",
44 46 "flatpak_adding": "Dodaję zdalne repozytorium Flathub...",
45 47 "flatpak_found": "Znaleziono {} wyników:",
46 48 "flatpak_info_branch": "Gałąź",
@@ -86,6 +88,8 @@
86 88 "pkg_not_found": "Nie znaleziono pakietu: {} (brak w repozytoriach)",
87 89 "provides_conflict": "Wielu dostawców dla '{name}' ({providers}) – używam '{chosen}'",
88 90 "provides_mapped": "{} → {} (provides)",
91 + "rdepends_none": "nic od niego nie zależy.",
92 + "rdepends_title": "Odwrotne zależności {} ({}):",
89 93 "removing": "Usuwanie",
90 94 "repo_added": "Dodano repozytorium: {}",
91 95 "repo_exists": "Repozytorium już istnieje: {}",
@@ -109,7 +113,18 @@
109 113 "sec_toobig": "Package too large: {size_mb}MB > {max_mb}MB",
110 114 "sec_toobig_pl": "Paczka za duza: {size_mb}MB > {max_mb}MB",
111 115 "sha256_mismatch": "niezgodność SHA256",
116 + "snapshot_created": "Utworzono snapshot: {}.",
117 + "snapshot_deleted": "Usunięto snapshot: {}.",
118 + "snapshot_list": "Snapshoty systemu ({}):",
119 + "snapshot_none": "Brak snapshotów systemu.",
120 + "snapshot_not_found": "Nie znaleziono snapshotu: {}",
121 + "snapshot_rollback_hint": "Wybierz ten wpis w menu GRUB: {}",
122 + "snapshot_rollback_next": "Następny start ustawiono na snapshot: {}",
123 + "snapshot_unsupported": "Snapshoty niedostępne: {}",
112 124 "ssl_broken": "Python bez działającego modułu ssl (HTTPS niemożliwe) – napraw pakiety python/openssl (np. sudo pag install -f python).",
125 + "staging_commit": "Wszystkie pakiety przygotowane – nakładam zmiany...",
126 + "staging_failed": "Etap przygotowania nieudany – system NIE został zmieniony.",
127 + "staging_prepare": "Przygotowuję {} pakietów w stagingu (system bez zmian)...",
113 128 "stats_base": "Baza (obraz) zarządzana",
114 129 "stats_cache": "Rozmiar cache",
115 130 "stats_files": "Śledzone pliki",
@@ -123,12 +138,10 @@
123 138 "updated_done": "Odświeżanie zakończone. {} pakietów w cache.",
124 139 "updates_available": "⚠ jest {} pakietów do zaktualizowania – wpisz: pag update",
125 140 "upgrading": "Aktualizacje: {} pakietów",
126 - "usage": "pag v4 – Pagan Linux Package Manager\n\nPODSTAWOWE:\n pag install <pkg>... Instalacja pakietów\n pag remove <pkg>... Usuwanie pakietów\n pag update Aktualizacja PAKIETÓW (odświeża indeksy)\n pag sync Odśwież indeksy + info o aktualizacjach\n pag upgrade Aktualizacja SYSTEMU (pakiety + kernel/initramfs/GRUB)\n pag list [--installed] Lista dostępnych / zainstalowanych\n pag search <query> Szukaj pakietów\n pag info <pkg> Szczegóły pakietu\n pag files <pkg> Lista plików pakietu\n pag verify [--deep] Weryfikacja integralności\n pag clean Wyczyść cache pobierania\n pag stats Statystyki systemu\n pag download <pkg>... Pobierz do cache (offline)\n\nROLLING (baza wypalona w obrazie):\n pag base [status] Pakiety z obrazu vs repo (czym pag zarządza)\n pag base adopt [pkg...] Adoptuj pakiety bazy z repo (--dry-run = podgląd)\n\nBEZPIECZEŃSTWO:\n pag key-add <url|file> Importuj klucz GPG\n pag key-list Lista zaufanych kluczy\n pag key-remove <id> Usuń klucz\n pag key-trust <repo> Przypnij fingerprint klucza repo (bez TOFU)\n pag key-untrust <repo> Zapomnij fingerprint repo (powrót do TOFU)\n pag key-trusted Lista przypiętych fingerprintów repo\n\nZAAWANSOWANE:\n pag why <pkg> Dlaczego pakiet jest zainstalowany\n pag autoremove Usuń osierocone zależności\n pag pin <pkg> [ver] Przypnij wersję pakietu\n pag unpin <pkg> Odepnij\n pag pinned Lista przypiętych\n pag history Historia transakcji\n pag rollback Cofnij ostatnią transakcję\n pag remove-orphans Usuń osierocone zależności\n pag repo-add <url> [nazwa] Dodaj repozytorium (drop-in w /etc/pag/repos/)\n pag repo-list Lista repozytoriów\n pag sbom export [fmt] Manifest SBOM (spdx|cyclonedx)\n\nFLATPAK:\n pag flatpak [<query>] Szukaj i instaluj\n pag flatpak search <q> Szukaj na Flathub\n pag flatpak install <id> Zainstaluj flatpak\n pag flatpak remove <id> Usuń flatpak\n pag flatpak list Lista zainstalowanych\n pag flatpak update Aktualizuj wszystkie\n pag flatpak info <id> Szczegóły flatpaka\n\nIMMUTABLE OS (PAG_IMMUTABLE=1):\n pag deploy-list Lista wdrożeń\n pag deploy-rollback Przełącz na poprzednie wdrożenie\n pag deploy-cleanup [N] Usuń stare wdrożenia (zachowaj N, domyślnie 3)\n pag initramfs-update Przebuduj initramfs\n pag grub-update Regeneruj wpisy GRUB",
141 + "usage": "pag v4 – Pagan Linux Package Manager\n\nPODSTAWOWE:\n pag install <pkg>... Instalacja pakietów\n pag remove <pkg>... Usuwanie pakietów\n pag update Aktualizacja PAKIETÓW (odświeża indeksy)\n pag sync Odśwież indeksy + info o aktualizacjach\n pag upgrade Aktualizacja SYSTEMU (pakiety + kernel/initramfs/GRUB)\n pag list [--installed] Lista dostępnych / zainstalowanych\n pag search <query> Szukaj pakietów\n pag info <pkg> Szczegóły pakietu\n pag files <pkg> Lista plików pakietu\n pag verify [--deep] Weryfikacja integralności\n pag clean Wyczyść cache pobierania\n pag stats Statystyki systemu\n pag download <pkg>... Pobierz do cache (offline)\n\nROLLING (baza wypalona w obrazie):\n pag base [status] Pakiety z obrazu vs repo (czym pag zarządza)\n pag base adopt [pkg...] Adoptuj pakiety bazy z repo (--dry-run = podgląd)\n\nBEZPIECZEŃSTWO:\n pag key-add <url|file> Importuj klucz GPG\n pag key-list Lista zaufanych kluczy\n pag key-remove <id> Usuń klucz\n pag key-trust <repo> Przypnij fingerprint klucza repo (bez TOFU)\n pag key-untrust <repo> Zapomnij fingerprint repo (powrót do TOFU)\n pag key-trusted Lista przypiętych fingerprintów repo\n\nZAAWANSOWANE:\n pag why <pkg> Dlaczego pakiet jest zainstalowany\n pag autoremove Usuń osierocone zależności\n pag pin <pkg> [ver] Przypnij wersję pakietu\n pag unpin <pkg> Odepnij\n pag pinned Lista przypiętych\n pag history Historia transakcji\n pag rollback Cofnij ostatnią transakcję\n pag remove-orphans Usuń osierocone zależności\n pag repo-add <url> [nazwa] Dodaj repozytorium (drop-in w /etc/pag/repos/)\n pag repo-list Lista repozytoriów\n pag sbom export [fmt] Manifest SBOM (spdx|cyclonedx)\n\nFLATPAK:\n pag flatpak [<query>] Szukaj i instaluj\n pag flatpak search <q> Szukaj na Flathub\n pag flatpak install <id> Zainstaluj flatpak\n pag flatpak remove <id> Usuń flatpak\n pag flatpak list Lista zainstalowanych\n pag flatpak update Aktualizuj wszystkie\n pag flatpak info <id> Szczegóły flatpaka\n\nSNAPSHOTY (btrfs CoW):\n pag snapshot-list Lista snapshotów systemu\n pag snapshot-create [opis] Utwórz snapshot teraz\n pag snapshot-rollback [id] Uruchom snapshot przy następnym starcie (GRUB)\n pag snapshot-delete <id> Usuń snapshot\n\nIMMUTABLE OS (PAG_IMMUTABLE=1):\n pag deploy-list Lista wdrożeń\n pag deploy-rollback Przełącz na poprzednie wdrożenie\n pag deploy-cleanup [N] Usuń stare wdrożenia (zachowaj N, domyślnie 3)\n pag initramfs-update Przebuduj initramfs\n pag grub-update Regeneruj wpisy GRUB",
127 142 "verify_errors": "Znaleziono {} problemów:",
128 143 "verify_ok": "Wszystkie {} plików sprawne.",
129 144 "why_dependency": "zależność od",
130 145 "why_explicit": "zainstalowany jawnie",
131 - "why_not_installed": "niezainstalowany",
132 - "rdepends_title": "Odwrotne zależności {} ({}):",
133 - "rdepends_none": "nic od niego nie zależy."
134 -}
146 + "why_not_installed": "niezainstalowany"
147 +}