linux-kernel-manager 0.1.2__py3-none-any.whl

lkm/core/providers/void.py

@@ -0,0 +1,69 @@
+"""Void Linux provider — xbps package manager."""
+from __future__ import annotations
+
+import platform
+import re
+from collections.abc import Iterator
+
+from lkm.core.kernel import KernelEntry, KernelFamily, KernelStatus, KernelVersion
+from lkm.core.providers.base import KernelProvider
+
+
+class VoidProvider(KernelProvider):
+
+    @property
+    def id(self) -> str:
+        return "void"
+
+    @property
+    def display_name(self) -> str:
+        return "Void Linux"
+
+    @property
+    def family(self) -> KernelFamily:
+        return KernelFamily.DISTRO
+
+    @property
+    def supported_arches(self) -> list[str]:
+        return ["*"]
+
+    def is_available(self) -> bool:
+        import shutil
+        return bool(shutil.which("xbps-install"))
+
+    def list(self, arch: str, refresh: bool = False) -> list[KernelEntry]:
+        running = platform.release()
+        if refresh:
+            # Consume and discard sync output
+            list(self._backend.sync())
+
+        names = self._backend.list_available_kernels()
+        entries = []
+        for name in names:
+            m = re.search(r"(\d+\.\d+(?:\.\d+)?)", name)
+            if not m:
+                continue
+            try:
+                ver = KernelVersion.parse(m.group(1))
+            except ValueError:
+                continue
+            installed = self._backend.is_installed(name)
+            if installed:
+                status = KernelStatus.RUNNING if m.group(1) in running else KernelStatus.INSTALLED
+            else:
+                status = KernelStatus.AVAILABLE
+            entries.append(KernelEntry(
+                version=ver,
+                family=self.family,
+                flavor=name,
+                arch=arch,
+                provider_id=self.id,
+                status=status,
+            ))
+        return entries
+
+    def install(self, entry: KernelEntry) -> Iterator[str]:
+        yield from self._backend.install_packages([entry.flavor])
+
+    def remove(self, entry: KernelEntry, purge: bool = False) -> Iterator[str]:
+        yield from self._backend.remove_packages([entry.flavor], purge=purge)

lkm/core/providers/xanmod.py

@@ -0,0 +1,81 @@
+"""XanMod provider — x86_64 only, apt repository."""
+from __future__ import annotations
+
+import shutil
+import urllib.request
+from collections.abc import Iterator
+
+from lkm.core.kernel import KernelEntry, KernelFamily, KernelStatus, KernelVersion
+from lkm.core.providers.base import KernelProvider
+from lkm.core.system import system_info
+
+_REPO_LINE = "deb [signed-by=/usr/share/keyrings/xanmod-archive-keyring.gpg] http://deb.xanmod.org releases main"
+_KEY_URL   = "https://dl.xanmod.org/archive.key"
+_FLAVORS   = ["xanmod1", "xanmod2", "xanmod3", "xanmod4", "edge", "lts", "rt"]
+
+
+class XanmodProvider(KernelProvider):
+
+    @property
+    def id(self) -> str:
+        return "xanmod"
+
+    @property
+    def display_name(self) -> str:
+        return "XanMod"
+
+    @property
+    def family(self) -> KernelFamily:
+        return KernelFamily.XANMOD
+
+    @property
+    def supported_arches(self) -> list[str]:
+        return ["amd64"]
+
+    def is_available(self) -> bool:
+        return bool(shutil.which("apt-get"))
+
+    def availability_reason(self) -> str:
+        return "XanMod requires apt (x86_64 only)."
+
+    def list(self, arch: str, refresh: bool = False) -> list[KernelEntry]:
+        running = system_info().running_kernel
+        try:
+            with urllib.request.urlopen(
+                "https://dl.xanmod.org/versions.json", timeout=10
+            ) as resp:
+                import json
+                data = json.loads(resp.read())
+        except Exception:
+            return []
+
+        entries = []
+        for item in data.get("kernels", []):
+            ver_str = item.get("version", "")
+            flavor  = item.get("flavor", "xanmod1")
+            try:
+                ver = KernelVersion.parse(ver_str)
+            except ValueError:
+                continue
+            status = KernelStatus.RUNNING if ver_str in running else KernelStatus.AVAILABLE
+            entries.append(KernelEntry(
+                version=ver,
+                family=self.family,
+                flavor=flavor,
+                arch=arch,
+                provider_id=self.id,
+                status=status,
+            ))
+        return entries
+
+    def install(self, entry: KernelEntry) -> Iterator[str]:
+        # Ensure the XanMod repo is present
+        yield "Adding XanMod repository...\n"
+        yield from self._backend.add_apt_repo(_REPO_LINE, _KEY_URL)
+        pkg = f"linux-xanmod-{entry.flavor}"
+        yield f"Installing {pkg}\n"
+        yield from self._backend.install_packages([pkg])
+
+    def remove(self, entry: KernelEntry, purge: bool = False) -> Iterator[str]:
+        pkg = f"linux-xanmod-{entry.flavor}"
+        yield from self._backend.remove_packages([pkg], purge=purge)

lkm/core/system.py

@@ -0,0 +1,235 @@
+"""
+System detection: distro, architecture, package manager, running kernel.
+
+All detection is lazy and cached. Call system_info() to get a SystemInfo
+snapshot; it is safe to call multiple times (returns the same object).
+
+Extended from ukm to add NixOS and Void Linux (xbps) support.
+"""
+from __future__ import annotations
+
+import os
+import platform
+import shutil
+import subprocess
+from dataclasses import dataclass, field
+from enum import Enum
+from functools import lru_cache
+from pathlib import Path
+
+
+class PackageManagerKind(Enum):
+    APT     = "apt"      # Debian / Ubuntu / Mint / etc.
+    PACMAN  = "pacman"   # Arch / Manjaro / EndeavourOS / CachyOS / etc.
+    DNF     = "dnf"      # Fedora / RHEL / AlmaLinux / Rocky / etc.
+    ZYPPER  = "zypper"   # openSUSE
+    APK     = "apk"      # Alpine
+    PORTAGE = "portage"  # Gentoo
+    XBPS    = "xbps"     # Void Linux
+    NIX     = "nix"      # NixOS
+    UNKNOWN = "unknown"
+
+
+class DistroFamily(Enum):
+    DEBIAN  = "debian"
+    ARCH    = "arch"
+    FEDORA  = "fedora"
+    SUSE    = "suse"
+    ALPINE  = "alpine"
+    GENTOO  = "gentoo"
+    VOID    = "void"
+    NIXOS   = "nixos"
+    UNKNOWN = "unknown"
+
+
+@dataclass(frozen=True)
+class DistroInfo:
+    id:       str
+    id_like:  list[str] = field(default_factory=list)
+    name:     str = ""
+    version:  str = ""
+    codename: str = ""
+    family:   DistroFamily = DistroFamily.UNKNOWN
+
+
+@dataclass(frozen=True)
+class SystemInfo:
+    distro:         DistroInfo
+    arch:           str   # normalised: amd64, arm64, armhf, riscv64, ppc64el, s390x, i386
+    arch_raw:       str   # as reported by uname -m
+    package_manager: PackageManagerKind
+    running_kernel: str   # uname -r output
+    has_secure_boot: bool
+    has_pkexec:     bool
+    has_sudo:       bool
+    in_nix_shell:   bool  # True when inside nix-shell / nix develop
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+def _read_os_release() -> dict[str, str]:
+    result: dict[str, str] = {}
+    for path in ("/etc/os-release", "/usr/lib/os-release"):
+        try:
+            with open(path) as f:
+                for line in f:
+                    line = line.strip()
+                    if "=" not in line or line.startswith("#"):
+                        continue
+                    k, _, v = line.partition("=")
+                    result[k.strip()] = v.strip().strip('"')
+            break
+        except FileNotFoundError:
+            continue
+    return result
+
+
+def _detect_distro() -> DistroInfo:
+    data = _read_os_release()
+    distro_id = data.get("ID", "").lower()
+    id_like   = [x.lower() for x in data.get("ID_LIKE", "").split()]
+    all_ids   = {distro_id} | set(id_like)
+
+    if distro_id == "nixos" or "nixos" in all_ids:
+        family = DistroFamily.NIXOS
+    elif distro_id == "void" or "void" in all_ids:
+        family = DistroFamily.VOID
+    elif any(x in all_ids for x in (
+        "debian", "ubuntu", "linuxmint", "pop", "elementary",
+        "kali", "parrot", "devuan", "raspbian", "mx",
+        "antix", "zorin", "sparky", "bunsenlabs",
+    )):
+        family = DistroFamily.DEBIAN
+    elif any(x in all_ids for x in (
+        "arch", "manjaro", "endeavouros", "cachyos",
+        "artix", "garuda", "rebornos", "archcraft",
+    )):
+        family = DistroFamily.ARCH
+    elif any(x in all_ids for x in (
+        "fedora", "rhel", "centos", "almalinux",
+        "rocky", "nobara", "ultramarine", "oracle",
+    )):
+        family = DistroFamily.FEDORA
+    elif any(x in all_ids for x in ("opensuse", "suse", "sles")):
+        family = DistroFamily.SUSE
+    elif "alpine" in all_ids:
+        family = DistroFamily.ALPINE
+    elif "gentoo" in all_ids:
+        family = DistroFamily.GENTOO
+    else:
+        family = DistroFamily.UNKNOWN
+
+    return DistroInfo(
+        id=distro_id,
+        id_like=id_like,
+        name=data.get("NAME", distro_id),
+        version=data.get("VERSION_ID", ""),
+        codename=data.get("VERSION_CODENAME", ""),
+        family=family,
+    )
+
+
+def _normalise_arch(raw: str) -> str:
+    """Map uname -m values to Debian-style arch names used throughout lkm."""
+    mapping = {
+        "x86_64":  "amd64",
+        "aarch64": "arm64",
+        "armv7l":  "armhf",
+        "armv6l":  "armel",
+        "i686":    "i386",
+        "i386":    "i386",
+        "riscv64": "riscv64",
+        "ppc64le": "ppc64el",
+        "s390x":   "s390x",
+    }
+    return mapping.get(raw, raw)
+
+
+def _detect_package_manager(family: DistroFamily) -> PackageManagerKind:
+    # Explicit binary detection takes priority over family inference so that
+    # distros with unusual setups (e.g. Arch with apt installed) still work.
+    checks = [
+        ("apt-get",      PackageManagerKind.APT),
+        ("pacman",       PackageManagerKind.PACMAN),
+        ("dnf",          PackageManagerKind.DNF),
+        ("zypper",       PackageManagerKind.ZYPPER),
+        ("apk",          PackageManagerKind.APK),
+        ("emerge",       PackageManagerKind.PORTAGE),
+        ("xbps-install", PackageManagerKind.XBPS),
+        ("nix-env",      PackageManagerKind.NIX),
+    ]
+    for cmd, kind in checks:
+        if shutil.which(cmd):
+            return kind
+
+    _family_map = {
+        DistroFamily.DEBIAN:  PackageManagerKind.APT,
+        DistroFamily.ARCH:    PackageManagerKind.PACMAN,
+        DistroFamily.FEDORA:  PackageManagerKind.DNF,
+        DistroFamily.SUSE:    PackageManagerKind.ZYPPER,
+        DistroFamily.ALPINE:  PackageManagerKind.APK,
+        DistroFamily.GENTOO:  PackageManagerKind.PORTAGE,
+        DistroFamily.VOID:    PackageManagerKind.XBPS,
+        DistroFamily.NIXOS:   PackageManagerKind.NIX,
+    }
+    return _family_map.get(family, PackageManagerKind.UNKNOWN)
+
+
+def _detect_secure_boot() -> bool:
+    if shutil.which("mokutil"):
+        try:
+            result = subprocess.run(
+                ["mokutil", "--sb-state"],
+                capture_output=True, text=True, timeout=3,
+            )
+            return "enabled" in result.stdout.lower()
+        except Exception:
+            pass
+    sb_var = Path(
+        "/sys/firmware/efi/efivars/"
+        "SecureBoot-8be4df61-93ca-11d2-aa0d-00e098032b8c"
+    )
+    if sb_var.exists():
+        try:
+            data = sb_var.read_bytes()
+            return len(data) >= 5 and data[4] == 1
+        except Exception:
+            pass
+    return False
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+@lru_cache(maxsize=1)
+def system_info() -> SystemInfo:
+    """Return a cached SystemInfo for the current machine."""
+    distro   = _detect_distro()
+    arch_raw = platform.machine()
+    arch     = _normalise_arch(arch_raw)
+    pm       = _detect_package_manager(distro.family)
+
+    return SystemInfo(
+        distro=distro,
+        arch=arch,
+        arch_raw=arch_raw,
+        package_manager=pm,
+        running_kernel=platform.release(),
+        has_secure_boot=_detect_secure_boot(),
+        has_pkexec=bool(shutil.which("pkexec")),
+        has_sudo=bool(shutil.which("sudo")),
+        in_nix_shell=bool(os.environ.get("IN_NIX_SHELL") or os.environ.get("LKM_NIX_SHELL")),
+    )
+
+
+def privilege_escalation_cmd() -> list[str]:
+    """Return the best available privilege escalation prefix."""
+    info = system_info()
+    if info.has_pkexec:
+        return ["pkexec"]
+    if info.has_sudo:
+        return ["sudo"]
+    return []

lkm/gui/app.py

@@ -0,0 +1,94 @@
+"""QApplication entry point for lkm-gui."""
+from __future__ import annotations
+
+import sys
+
+from lkm.gui.main_window import MainWindow
+from lkm.qt import QApplication
+
+_STYLESHEET = """
+QMainWindow, QDialog {
+    background-color: #1e1e2e;
+    color: #cdd6f4;
+}
+QTabWidget::pane {
+    border: 1px solid #45475a;
+}
+QTabBar::tab {
+    background: #313244;
+    color: #cdd6f4;
+    padding: 6px 14px;
+    border-radius: 4px 4px 0 0;
+}
+QTabBar::tab:selected {
+    background: #89b4fa;
+    color: #1e1e2e;
+}
+QTableView {
+    background-color: #181825;
+    alternate-background-color: #1e1e2e;
+    gridline-color: #313244;
+    color: #cdd6f4;
+    selection-background-color: #45475a;
+}
+QHeaderView::section {
+    background-color: #313244;
+    color: #cdd6f4;
+    padding: 4px;
+    border: none;
+}
+QToolBar {
+    background-color: #181825;
+    border-bottom: 1px solid #313244;
+    spacing: 4px;
+}
+QStatusBar {
+    background-color: #181825;
+    color: #a6adc8;
+}
+QPushButton {
+    background-color: #313244;
+    color: #cdd6f4;
+    border: 1px solid #45475a;
+    border-radius: 4px;
+    padding: 4px 12px;
+}
+QPushButton:hover  { background-color: #45475a; }
+QPushButton:pressed { background-color: #585b70; }
+QPushButton:default { border-color: #89b4fa; }
+QLineEdit, QComboBox, QTextEdit, QSpinBox {
+    background-color: #313244;
+    color: #cdd6f4;
+    border: 1px solid #45475a;
+    border-radius: 4px;
+    padding: 2px 6px;
+}
+QGroupBox {
+    border: 1px solid #45475a;
+    border-radius: 4px;
+    margin-top: 8px;
+    color: #a6adc8;
+}
+QGroupBox::title {
+    subcontrol-origin: margin;
+    left: 8px;
+    padding: 0 4px;
+}
+QCheckBox { color: #cdd6f4; }
+QLabel    { color: #cdd6f4; }
+"""
+
+
+def main() -> None:
+    app = QApplication(sys.argv)
+    app.setApplicationName("lkm")
+    app.setApplicationVersion("0.1.0")
+    app.setStyleSheet(_STYLESHEET)
+
+    win = MainWindow()
+    win.show()
+    sys.exit(app.exec())
+
+
+if __name__ == "__main__":
+    main()

lkm/gui/kernel_model.py

@@ -0,0 +1,98 @@
+"""QAbstractTableModel wrapping a list of KernelEntry objects."""
+from __future__ import annotations
+
+from lkm.core.kernel import KernelEntry, KernelStatus
+from lkm.qt import (
+    QAbstractTableModel,
+    QColor,
+    QFont,
+    QModelIndex,
+    Qt,
+)
+
+_COLUMNS = ["Version", "Family", "Flavor", "Arch", "Status", "Notes"]
+_COL_VERSION = 0
+_COL_FAMILY  = 1
+_COL_FLAVOR  = 2
+_COL_ARCH    = 3
+_COL_STATUS  = 4
+_COL_NOTES   = 5
+
+_STATUS_COLORS = {
+    KernelStatus.RUNNING:   "#2ecc71",
+    KernelStatus.INSTALLED: "#3498db",
+    KernelStatus.HELD:      "#e67e22",
+    KernelStatus.AVAILABLE: None,
+}
+
+
+class KernelTableModel(QAbstractTableModel):
+
+    def __init__(self, entries: list[KernelEntry] | None = None, parent=None) -> None:
+        super().__init__(parent)
+        self._entries: list[KernelEntry] = entries or []
+
+    def set_entries(self, entries: list[KernelEntry]) -> None:
+        self.beginResetModel()
+        self._entries = entries
+        self.endResetModel()
+
+    def entry_at(self, row: int) -> KernelEntry | None:
+        if 0 <= row < len(self._entries):
+            return self._entries[row]
+        return None
+
+    # ------------------------------------------------------------------
+    # QAbstractTableModel interface
+    # ------------------------------------------------------------------
+
+    def rowCount(self, parent: QModelIndex = QModelIndex()) -> int:
+        return len(self._entries)
+
+    def columnCount(self, parent: QModelIndex = QModelIndex()) -> int:
+        return len(_COLUMNS)
+
+    def headerData(self, section: int, orientation, role=Qt.ItemDataRole.DisplayRole):
+        if orientation == Qt.Orientation.Horizontal and role == Qt.ItemDataRole.DisplayRole:
+            return _COLUMNS[section]
+        return None
+
+    def data(self, index: QModelIndex, role=Qt.ItemDataRole.DisplayRole):
+        if not index.isValid():
+            return None
+        entry = self._entries[index.row()]
+        col   = index.column()
+
+        if role == Qt.ItemDataRole.DisplayRole:
+            return self._display(entry, col)
+
+        if role == Qt.ItemDataRole.ForegroundRole:
+            color = _STATUS_COLORS.get(entry.status)
+            if color:
+                return QColor(color)
+
+        if role == Qt.ItemDataRole.FontRole and entry.is_running:
+            f = QFont()
+            f.setBold(True)
+            return f
+
+        if role == Qt.ItemDataRole.UserRole:
+            return entry
+
+        return None
+
+    def _display(self, entry: KernelEntry, col: int) -> str:
+        if col == _COL_VERSION:
+            return str(entry.version)
+        if col == _COL_FAMILY:
+            return entry.family.value
+        if col == _COL_FLAVOR:
+            return entry.flavor
+        if col == _COL_ARCH:
+            return entry.arch
+        if col == _COL_STATUS:
+            s = entry.status.value
+            return s + " [held]" if entry.held else s
+        if col == _COL_NOTES:
+            return entry.notes[:60] if entry.notes else ""
+        return ""