diskman 0.2.1__py3-none-any.whl

diskman/__init__.py

@@ -0,0 +1,2 @@
+__all__ = ["__version__"]
+__version__ = "0.2.1"

diskman/cli.py

@@ -0,0 +1,253 @@
+from __future__ import annotations
+
+import argparse
+import getpass
+import io
+import sys
+from pathlib import Path
+
+from diskman.core import (
+    DEFAULT_BASE_DIR,
+    CommandError,
+    automount,
+    automount_async,
+    collect_partitions,
+    disable_persistent_mount,
+    enable_persistent_mount,
+    find_partition,
+    is_luks_open,
+    is_mountable,
+    is_root_partition,
+    lock_luks,
+    mount_partition,
+    mount_partition_async,
+    persistent_mount_map,
+    require_root,
+    root_sources,
+    smart_health,
+    umount_partition,
+    umount_partition_async,
+    unlock_luks,
+)
+from diskman.tui import run_tui
+
+
+def _flags_for_part(p, roots, boot_map):
+    flags = []
+    if is_root_partition(p, roots):
+        flags.append("ROOT")
+    if p.mounted:
+        flags.append("MOUNTED")
+    if not is_mountable(p):
+        flags.append("SKIP")
+    if p.is_luks:
+        flags.append("LUKS_OPEN" if is_luks_open(p) else "LUKS_LOCKED")
+    if p.uuid and p.uuid in boot_map:
+        flags.append("AUTOBOOT")
+    return flags
+
+
+def render_table(parts) -> str:
+    roots = root_sources()
+    boot_map = persistent_mount_map()
+
+    try:
+        from rich.console import Console
+        from rich.table import Table
+
+        table = Table(title="diskman partitions")
+        table.add_column("Device")
+        table.add_column("Type")
+        table.add_column("Disk")
+        table.add_column("FS")
+        table.add_column("Size")
+        table.add_column("Mountpoint")
+        table.add_column("SMART")
+        table.add_column("Flags")
+
+        for p in parts:
+            flags = _flags_for_part(p, roots, boot_map)
+            table.add_row(
+                p.path,
+                p.devtype or "-",
+                p.disk_kind or "-",
+                p.fstype or "-",
+                p.size or "-",
+                p.mountpoint or "-",
+                smart_health(p),
+                ",".join(flags) or "-",
+            )
+
+        out = io.StringIO()
+        console = Console(file=out, force_terminal=False, color_system=None)
+        console.print(table)
+        return out.getvalue()
+    except Exception:
+        header = (
+            f"{'DEVICE':<18} {'TYPE':<7} {'DISK':<5} {'FS':<10} {'SIZE':<8} "
+            f"{'MOUNTPOINT':<22} {'SMART':<12} {'FLAGS'}"
+        )
+        lines = [header, "-" * len(header)]
+        for p in parts:
+            flags = _flags_for_part(p, roots, boot_map)
+            lines.append(
+                f"{p.path:<18} {p.devtype:<7} {p.disk_kind:<5} {p.fstype or '-':<10} {p.size or '-':<8} "
+                f"{p.mountpoint or '-':<22} {smart_health(p):<12} {','.join(flags) or '-'}"
+            )
+        return "\n".join(lines)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="diskman",
+        description="CLI + TUI disk/partition manager with auto-mount (excluding root).",
+    )
+    parser.add_argument(
+        "--base-dir",
+        default=str(DEFAULT_BASE_DIR),
+        help="Base mount directory for auto/manual mounts (default: /mnt/auto)",
+    )
+
+    sub = parser.add_subparsers(dest="cmd", required=True)
+    sub.add_parser("list", help="List partitions and mount status")
+
+    auto = sub.add_parser("automount", help="Auto-mount all mountable partitions except root")
+    auto.add_argument("--dry-run", action="store_true", help="Show what would be mounted")
+    auto.add_argument("--async", dest="is_async", action="store_true", help="Run automount in a background worker")
+
+    mount_p = sub.add_parser("mount", help="Mount one device")
+    mount_p.add_argument("device", help="Device path, e.g. /dev/sdb1")
+    mount_p.add_argument("--async", dest="is_async", action="store_true", help="Run mount in a background worker")
+
+    umount_p = sub.add_parser("umount", help="Unmount one device")
+    umount_p.add_argument("device", help="Device path, e.g. /dev/sdb1")
+    umount_p.add_argument("--lock-luks", action="store_true", help="If device is LUKS, close mapper after unmount")
+    umount_p.add_argument("--async", dest="is_async", action="store_true", help="Run unmount in a background worker")
+
+    sub.add_parser("boot-list", help="List diskman reboot auto-mount entries in fstab")
+
+    boot_add = sub.add_parser("boot-add", help="Enable reboot auto-mount for one device")
+    boot_add.add_argument("device", help="Device path, e.g. /dev/sdb1")
+
+    boot_rm = sub.add_parser("boot-remove", help="Disable reboot auto-mount for one device")
+    boot_rm.add_argument("device", help="Device path, e.g. /dev/sdb1")
+
+    luks_unlock = sub.add_parser("luks-unlock", help="Unlock a LUKS device")
+    luks_unlock.add_argument("device", help="LUKS device path, e.g. /dev/sdb2")
+
+    luks_lock = sub.add_parser("luks-lock", help="Lock a LUKS device mapper")
+    luks_lock.add_argument("device", help="LUKS device path, e.g. /dev/sdb2")
+
+    sub.add_parser("tui", help="Start terminal UI")
+    return parser
+
+
+def _prompt_luks_passphrase() -> str:
+    return getpass.getpass("LUKS passphrase: ")
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    base_dir = Path(args.base_dir)
+
+    try:
+        if args.cmd == "list":
+            print(render_table(collect_partitions()))
+            return 0
+
+        if args.cmd == "automount":
+            if not args.dry_run:
+                require_root()
+            if args.is_async:
+                logs = automount_async(base_dir=base_dir, dry_run=args.dry_run).result()
+            else:
+                logs = automount(base_dir=base_dir, dry_run=args.dry_run)
+            for line in logs:
+                print(line)
+            return 0
+
+        if args.cmd == "mount":
+            require_root()
+            part = find_partition(collect_partitions(), args.device)
+            if not part:
+                raise CommandError(f"Device not found: {args.device}")
+
+            passphrase = None
+            if part.is_luks and not is_luks_open(part):
+                passphrase = _prompt_luks_passphrase()
+
+            if args.is_async:
+                _, msg = mount_partition_async(part, base_dir, root_sources(), passphrase).result()
+            else:
+                _, msg = mount_partition(part, base_dir, root_sources(), passphrase)
+            print(msg)
+            return 0
+
+        if args.cmd == "umount":
+            require_root()
+            part = find_partition(collect_partitions(), args.device)
+            if not part:
+                raise CommandError(f"Device not found: {args.device}")
+            if args.is_async:
+                _, msg = umount_partition_async(part, root_sources(), args.lock_luks).result()
+            else:
+                _, msg = umount_partition(part, root_sources(), args.lock_luks)
+            print(msg)
+            return 0
+
+        if args.cmd == "tui":
+            run_tui(base_dir)
+            return 0
+
+        if args.cmd == "boot-list":
+            boot_map = persistent_mount_map()
+            if not boot_map:
+                print("No diskman reboot auto-mount entries found.")
+                return 0
+            for uuid, mnt in boot_map.items():
+                print(f"UUID={uuid} -> {mnt}")
+            return 0
+
+        if args.cmd == "boot-add":
+            require_root()
+            part = find_partition(collect_partitions(), args.device)
+            if not part:
+                raise CommandError(f"Device not found: {args.device}")
+            print(enable_persistent_mount(part, base_dir, root_sources()))
+            return 0
+
+        if args.cmd == "boot-remove":
+            require_root()
+            part = find_partition(collect_partitions(), args.device)
+            if not part:
+                raise CommandError(f"Device not found: {args.device}")
+            print(disable_persistent_mount(part))
+            return 0
+
+        if args.cmd == "luks-unlock":
+            require_root()
+            part = find_partition(collect_partitions(), args.device)
+            if not part:
+                raise CommandError(f"Device not found: {args.device}")
+            passphrase = _prompt_luks_passphrase()
+            mapper = unlock_luks(part, passphrase)
+            print(f"Unlocked {part.path} -> {mapper}")
+            return 0
+
+        if args.cmd == "luks-lock":
+            require_root()
+            part = find_partition(collect_partitions(), args.device)
+            if not part:
+                raise CommandError(f"Device not found: {args.device}")
+            print(lock_luks(part))
+            return 0
+
+        raise CommandError(f"Unknown command: {args.cmd}")
+    except CommandError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

diskman/core.py

@@ -0,0 +1,503 @@
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+from concurrent.futures import Future, ThreadPoolExecutor
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Tuple
+
+LSBLK_COLUMNS = "NAME,KNAME,PATH,TYPE,PKNAME,FSTYPE,LABEL,UUID,SIZE,MOUNTPOINT,ROTA"
+DEFAULT_BASE_DIR = Path("/mnt/auto")
+DEFAULT_FSTAB_PATH = Path("/etc/fstab")
+DISKMAN_FSTAB_TAG = "diskman:auto"
+
+_smart_cache: dict[str, str] = {}
+_executor = ThreadPoolExecutor(max_workers=4)
+
+
+@dataclass
+class Partition:
+    name: str
+    kname: str
+    path: str
+    devtype: str
+    pkname: str
+    disk_path: str
+    disk_kind: str
+    fstype: str
+    label: str
+    uuid: str
+    size: str
+    mountpoint: str
+
+    @property
+    def mounted(self) -> bool:
+        return bool(self.mountpoint)
+
+    @property
+    def is_luks(self) -> bool:
+        return self.fstype.lower() == "crypto_luks"
+
+
+class CommandError(RuntimeError):
+    pass
+
+
+def run_cmd(cmd: List[str], check: bool = True, input_text: str | None = None) -> str:
+    proc = subprocess.run(cmd, text=True, capture_output=True, input=input_text)
+    if check and proc.returncode != 0:
+        raise CommandError((proc.stderr or proc.stdout or "command failed").strip())
+    return proc.stdout.strip()
+
+
+def run_cmd_proc(cmd: List[str], input_text: str | None = None) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(cmd, text=True, capture_output=True, input=input_text)
+
+
+def lsblk_json() -> dict:
+    out = run_cmd(["lsblk", "-J", "-p", "-o", LSBLK_COLUMNS])
+    return json.loads(out)
+
+
+def iter_nodes(node: dict):
+    yield node
+    for child in node.get("children", []):
+        yield from iter_nodes(child)
+
+
+def _rota_to_kind(rota: object) -> str:
+    if rota is True or str(rota).strip() == "1":
+        return "HDD"
+    if rota is False or str(rota).strip() == "0":
+        return "SSD"
+    return "UNKNOWN"
+
+
+def _pick_mount_options(part: Partition, read_only: bool = False) -> str:
+    opts = ["defaults", "nofail", "noatime"]
+    if read_only:
+        opts.append("ro")
+
+    fs = part.fstype.lower()
+    if fs in {"ext4", "xfs", "btrfs", "f2fs"} and part.disk_kind == "SSD":
+        opts.append("discard")
+    if fs in {"vfat", "fat", "fat32", "exfat"}:
+        opts.extend([f"uid={os.getuid()}", f"gid={os.getgid()}", "umask=022"])
+    if fs == "ntfs3":
+        opts.extend([f"uid={os.getuid()}", f"gid={os.getgid()}", "windows_names"])
+
+    # Keep order stable and unique.
+    return ",".join(dict.fromkeys(opts))
+
+
+def _mount_once(path: str, mountpoint: str, options: str | None = None) -> subprocess.CompletedProcess[str]:
+    cmd = ["mount"]
+    if options:
+        cmd.extend(["-o", options])
+    cmd.extend([path, mountpoint])
+    return run_cmd_proc(cmd)
+
+
+def _mount_with_read_only_fallback(part: Partition, mountpoint: Path) -> Tuple[bool, str]:
+    rw_opts = _pick_mount_options(part, read_only=False)
+    proc = _mount_once(part.path, str(mountpoint), rw_opts)
+    if proc.returncode == 0:
+        return True, f"Mounted {part.path} -> {mountpoint} ({rw_opts})"
+
+    ro_opts = _pick_mount_options(part, read_only=True)
+    ro_proc = _mount_once(part.path, str(mountpoint), ro_opts)
+    if ro_proc.returncode == 0:
+        reason = (proc.stderr or proc.stdout or "rw mount failed").strip()
+        return True, f"Mounted read-only {part.path} -> {mountpoint} ({ro_opts}); reason: {reason}"
+
+    err = (ro_proc.stderr or ro_proc.stdout or proc.stderr or proc.stdout or "mount failed").strip()
+    return False, f"Mount failed for {part.path}: {err}"
+
+
+def _luks_mapper_name(part: Partition) -> str:
+    safe = Path(part.kname).name.replace("/", "-")
+    return f"diskman-{safe}"
+
+
+def _luks_mapper_path(mapper_name: str) -> str:
+    return f"/dev/mapper/{mapper_name}"
+
+
+def is_luks_open(part: Partition) -> bool:
+    mapper_name = _luks_mapper_name(part)
+    mapper_path = _luks_mapper_path(mapper_name)
+    return Path(mapper_path).exists()
+
+
+def unlock_luks(part: Partition, passphrase: str) -> str:
+    if not part.is_luks:
+        raise CommandError(f"Not a LUKS device: {part.path}")
+
+    mapper_name = _luks_mapper_name(part)
+    proc = run_cmd_proc(["cryptsetup", "open", part.path, mapper_name, "--key-file", "-"], input_text=passphrase)
+    if proc.returncode != 0:
+        raise CommandError((proc.stderr or proc.stdout or "cryptsetup open failed").strip())
+    return _luks_mapper_path(mapper_name)
+
+
+def lock_luks(part: Partition) -> str:
+    if not part.is_luks:
+        raise CommandError(f"Not a LUKS device: {part.path}")
+    mapper_name = _luks_mapper_name(part)
+    run_cmd(["cryptsetup", "close", mapper_name])
+    return f"Closed LUKS mapper: {mapper_name}"
+
+
+def _resolve_luks_inner(part: Partition) -> str:
+    mapper_name = _luks_mapper_name(part)
+    mapper_path = _luks_mapper_path(mapper_name)
+    if not Path(mapper_path).exists():
+        raise CommandError(f"LUKS device is locked: {part.path}. Unlock first.")
+
+    out = run_cmd(["lsblk", "-J", "-p", "-o", "PATH,FSTYPE", mapper_path])
+    data = json.loads(out)
+    nodes = data.get("blockdevices", [])
+    if not nodes:
+        return mapper_path
+    node = nodes[0]
+    children = node.get("children", [])
+    if children:
+        child_path = (children[0].get("path") or "").strip()
+        if child_path.startswith("/dev/"):
+            return child_path
+    return mapper_path
+
+
+def _physical_disk_path(node: dict, top_path: str) -> str:
+    pkname = (node.get("pkname") or "").strip()
+    if pkname:
+        if pkname.startswith("/dev/"):
+            return pkname
+        return f"/dev/{pkname}"
+    return top_path
+
+
+def collect_partitions() -> List[Partition]:
+    data = lsblk_json()
+    partitions: List[Partition] = []
+    for top in data.get("blockdevices", []):
+        top_path = (top.get("path") or "").strip()
+        top_kind = _rota_to_kind(top.get("rota"))
+        for node in iter_nodes(top):
+            devtype = (node.get("type") or "").strip()
+            path = (node.get("path") or "").strip()
+            if not path.startswith("/dev/"):
+                continue
+            if devtype in {"disk", "loop", "rom"}:
+                continue
+
+            disk_path = _physical_disk_path(node, top_path)
+            partitions.append(
+                Partition(
+                    name=(node.get("name") or "").strip(),
+                    kname=(node.get("kname") or "").strip(),
+                    path=path,
+                    devtype=devtype,
+                    pkname=(node.get("pkname") or "").strip(),
+                    disk_path=disk_path,
+                    disk_kind=top_kind,
+                    fstype=(node.get("fstype") or "").strip(),
+                    label=(node.get("label") or "").strip(),
+                    uuid=(node.get("uuid") or "").strip(),
+                    size=(node.get("size") or "").strip(),
+                    mountpoint=(node.get("mountpoint") or "").strip(),
+                )
+            )
+
+    partitions.sort(key=lambda p: p.path)
+    return partitions
+
+
+def root_sources() -> set[str]:
+    source = run_cmd(["findmnt", "-n", "-o", "SOURCE", "/"])
+    source = source.strip()
+    if not source:
+        return set()
+    if source.startswith("/dev/"):
+        return {source.split("[", 1)[0]}
+    return set()
+
+
+def is_root_partition(part: Partition, root_devs: set[str]) -> bool:
+    return part.path in root_devs or part.mountpoint == "/"
+
+
+def is_mountable(part: Partition) -> bool:
+    if not part.fstype:
+        return False
+    if part.fstype.lower() == "swap":
+        return False
+    if part.is_luks:
+        # LUKS container needs unlock before mount.
+        return True
+    return True
+
+
+def target_mount_point(part: Partition, base_dir: Path) -> Path:
+    return base_dir / Path(part.path).name
+
+
+def ensure_dir(path: Path) -> None:
+    path.mkdir(parents=True, exist_ok=True)
+
+
+def require_root() -> None:
+    if os.geteuid() != 0:
+        raise CommandError("This operation requires root. Re-run with sudo.")
+
+
+def find_partition(parts: List[Partition], device: str) -> Partition | None:
+    for part in parts:
+        if part.path == device:
+            return part
+    return None
+
+
+def _smart_health_for_disk(disk_path: str) -> str:
+    if disk_path in _smart_cache:
+        return _smart_cache[disk_path]
+
+    # smartctl may require root and may not exist on all systems.
+    try:
+        proc = run_cmd_proc(["smartctl", "-H", "-j", disk_path])
+    except FileNotFoundError:
+        _smart_cache[disk_path] = "NO_SMARTCTL"
+        return _smart_cache[disk_path]
+
+    if proc.returncode != 0 and not proc.stdout:
+        _smart_cache[disk_path] = "UNAVAILABLE"
+        return _smart_cache[disk_path]
+
+    try:
+        payload = json.loads(proc.stdout or "{}")
+    except json.JSONDecodeError:
+        _smart_cache[disk_path] = "UNKNOWN"
+        return _smart_cache[disk_path]
+
+    smart_status = payload.get("smart_status") or {}
+    passed = smart_status.get("passed")
+    if passed is True:
+        status = "PASSED"
+    elif passed is False:
+        status = "FAILED"
+    else:
+        # Fallback to short text status fields if present.
+        status = (
+            str(payload.get("ata_smart_data", {}).get("self_test", {}).get("status", {}).get("string") or "")
+            .strip()
+            .upper()
+            or "UNKNOWN"
+        )
+
+    _smart_cache[disk_path] = status
+    return status
+
+
+def smart_health(part: Partition) -> str:
+    return _smart_health_for_disk(part.disk_path)
+
+
+def is_mount_read_only(part: Partition) -> bool:
+    if not part.mountpoint:
+        return False
+    proc = run_cmd_proc(["findmnt", "-n", "-o", "OPTIONS", "--target", part.mountpoint])
+    if proc.returncode != 0:
+        return False
+    options = (proc.stdout or "").strip().split(",")
+    return "ro" in options
+
+
+def mount_partition(
+    part: Partition,
+    base_dir: Path,
+    root_devs: set[str],
+    luks_passphrase: str | None = None,
+) -> Tuple[bool, str]:
+    if is_root_partition(part, root_devs):
+        return False, f"Skipping root partition: {part.path}"
+    if not is_mountable(part):
+        return False, f"Not mountable: {part.path}"
+    if part.mounted:
+        return False, f"Already mounted: {part.path} -> {part.mountpoint}"
+
+    mount_source = part.path
+    if part.is_luks:
+        if not is_luks_open(part):
+            if luks_passphrase is None:
+                return False, f"LUKS device locked: {part.path}"
+            unlock_luks(part, luks_passphrase)
+        mount_source = _resolve_luks_inner(part)
+
+    mnt = target_mount_point(part, base_dir)
+    ensure_dir(mnt)
+
+    # Try filesystem-aware rw mount first; fallback to read-only.
+    effective = Partition(**{**part.__dict__, "path": mount_source, "fstype": part.fstype})
+    ok, msg = _mount_with_read_only_fallback(effective, mnt)
+    if ok:
+        return True, msg
+    return False, msg
+
+
+def umount_partition(part: Partition, root_devs: set[str], lock_luks_after: bool = False) -> Tuple[bool, str]:
+    if is_root_partition(part, root_devs):
+        return False, f"Skipping root partition: {part.path}"
+    if not part.mounted:
+        if part.is_luks and lock_luks_after and is_luks_open(part):
+            lock_msg = lock_luks(part)
+            return True, f"Not mounted; {lock_msg}"
+        return False, f"Not mounted: {part.path}"
+
+    run_cmd(["umount", part.path])
+    if part.is_luks and lock_luks_after and is_luks_open(part):
+        lock_msg = lock_luks(part)
+        return True, f"Unmounted {part.path}; {lock_msg}"
+    return True, f"Unmounted {part.path}"
+
+
+def automount(base_dir: Path, dry_run: bool = False) -> List[str]:
+    logs: List[str] = []
+    parts = collect_partitions()
+    roots = root_sources()
+
+    for part in parts:
+        if is_root_partition(part, roots):
+            logs.append(f"SKIP root: {part.path}")
+            continue
+        if not is_mountable(part):
+            logs.append(f"SKIP unsupported: {part.path}")
+            continue
+        if part.mounted:
+            logs.append(f"SKIP already mounted: {part.path} -> {part.mountpoint}")
+            continue
+        if part.is_luks and not is_luks_open(part):
+            logs.append(f"SKIP locked LUKS: {part.path}")
+            continue
+
+        mnt = target_mount_point(part, base_dir)
+        if dry_run:
+            logs.append(f"DRY-RUN mount {part.path} -> {mnt}")
+            continue
+
+        try:
+            ensure_dir(mnt)
+            _, msg = mount_partition(part, base_dir, roots)
+            logs.append(f"OK {msg}")
+        except Exception as exc:
+            logs.append(f"ERR mount {part.path}: {exc}")
+
+    return logs
+
+
+def automount_async(base_dir: Path, dry_run: bool = False) -> Future[List[str]]:
+    return _executor.submit(automount, base_dir, dry_run)
+
+
+def mount_partition_async(
+    part: Partition,
+    base_dir: Path,
+    root_devs: set[str],
+    luks_passphrase: str | None = None,
+) -> Future[Tuple[bool, str]]:
+    return _executor.submit(mount_partition, part, base_dir, root_devs, luks_passphrase)
+
+
+def umount_partition_async(
+    part: Partition,
+    root_devs: set[str],
+    lock_luks_after: bool = False,
+) -> Future[Tuple[bool, str]]:
+    return _executor.submit(umount_partition, part, root_devs, lock_luks_after)
+
+
+def unlock_luks_async(part: Partition, passphrase: str) -> Future[str]:
+    return _executor.submit(unlock_luks, part, passphrase)
+
+
+def lock_luks_async(part: Partition) -> Future[str]:
+    return _executor.submit(lock_luks, part)
+
+
+def persistent_mount_map(fstab_path: Path = DEFAULT_FSTAB_PATH) -> dict[str, str]:
+    entries: dict[str, str] = {}
+    try:
+        lines = fstab_path.read_text(encoding="utf-8").splitlines()
+    except FileNotFoundError:
+        return entries
+
+    for line in lines:
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#"):
+            continue
+        if DISKMAN_FSTAB_TAG not in stripped:
+            continue
+
+        fields = stripped.split()
+        if len(fields) < 2:
+            continue
+        spec = fields[0]
+        mountpoint = fields[1]
+        if spec.startswith("UUID="):
+            entries[spec.removeprefix("UUID=")] = mountpoint
+
+    return entries
+
+
+def fstab_line_for_partition(part: Partition, base_dir: Path) -> str:
+    if not part.uuid:
+        raise CommandError(f"Missing UUID for {part.path}; cannot persist in fstab safely.")
+    if not is_mountable(part):
+        raise CommandError(f"Partition is not mountable: {part.path}")
+    if part.is_luks:
+        raise CommandError(f"Refusing to persist raw LUKS container in fstab: {part.path}")
+    mnt = target_mount_point(part, base_dir)
+    opts = _pick_mount_options(part, read_only=False)
+    return f"UUID={part.uuid} {mnt} {part.fstype} {opts} 0 2 # {DISKMAN_FSTAB_TAG} {part.path}"
+
+
+def enable_persistent_mount(
+    part: Partition, base_dir: Path, root_devs: set[str], fstab_path: Path = DEFAULT_FSTAB_PATH
+) -> str:
+    if is_root_partition(part, root_devs):
+        raise CommandError(f"Refusing to persist root partition: {part.path}")
+    ensure_dir(target_mount_point(part, base_dir))
+    existing = persistent_mount_map(fstab_path)
+    if part.uuid in existing:
+        return f"Persistent mount already enabled for {part.path} -> {existing[part.uuid]}"
+
+    line = fstab_line_for_partition(part, base_dir)
+    with fstab_path.open("a", encoding="utf-8") as f:
+        f.write("\n" + line + "\n")
+    return f"Enabled reboot auto-mount for {part.path}"
+
+
+def disable_persistent_mount(part: Partition, fstab_path: Path = DEFAULT_FSTAB_PATH) -> str:
+    if not part.uuid:
+        raise CommandError(f"Missing UUID for {part.path}; cannot remove from fstab safely.")
+    try:
+        lines = fstab_path.read_text(encoding="utf-8").splitlines()
+    except FileNotFoundError:
+        raise CommandError(f"fstab not found: {fstab_path}")
+
+    kept: List[str] = []
+    removed = False
+    uuid_key = f"UUID={part.uuid}"
+    for line in lines:
+        stripped = line.strip()
+        if stripped and not stripped.startswith("#") and DISKMAN_FSTAB_TAG in stripped and uuid_key in stripped:
+            removed = True
+            continue
+        kept.append(line)
+
+    if not removed:
+        return f"Persistent mount was not enabled for {part.path}"
+
+    fstab_path.write_text("\n".join(kept).rstrip() + "\n", encoding="utf-8")
+    return f"Disabled reboot auto-mount for {part.path}"

diskman/tui.py

@@ -0,0 +1,211 @@
+from __future__ import annotations
+
+import curses
+from concurrent.futures import Future
+from pathlib import Path
+
+from .core import (
+    automount_async,
+    collect_partitions,
+    disable_persistent_mount,
+    enable_persistent_mount,
+    is_mount_read_only,
+    is_luks_open,
+    is_mountable,
+    is_root_partition,
+    lock_luks_async,
+    mount_partition_async,
+    persistent_mount_map,
+    require_root,
+    root_sources,
+    smart_health,
+    unlock_luks_async,
+    umount_partition_async,
+)
+
+
+def _prompt_hidden(stdscr, y: int, x: int, prompt: str) -> str:
+    curses.noecho()
+    stdscr.addstr(y, x, prompt)
+    stdscr.refresh()
+    buf = []
+    while True:
+        key = stdscr.getch()
+        if key in (10, 13):
+            break
+        if key in (curses.KEY_BACKSPACE, 127, 8):
+            if buf:
+                buf.pop()
+                stdscr.addstr(y, x + len(prompt) + len(buf), " ")
+                stdscr.move(y, x + len(prompt) + len(buf))
+                stdscr.refresh()
+            continue
+        if 32 <= key <= 126:
+            buf.append(chr(key))
+            stdscr.addstr(y, x + len(prompt) + len(buf) - 1, "*")
+            stdscr.refresh()
+    return "".join(buf)
+
+
+def run_tui(base_dir: Path) -> None:
+    def tui(stdscr) -> None:
+        curses.curs_set(0)
+        stdscr.nodelay(True)
+        stdscr.keypad(True)
+        index = 0
+        nav = "r:refresh a:auto m:mount/unmount u:unlock l:lock p:boot q:quit"
+        status = "Ready"
+        parts = collect_partitions()
+        pending: Future | None = None
+        pending_action = ""
+
+        while True:
+            if pending and pending.done():
+                try:
+                    result = pending.result()
+                    if isinstance(result, tuple):
+                        _, status = result
+                    elif isinstance(result, list):
+                        status = result[-1] if result else "No changes"
+                    else:
+                        status = str(result)
+                except Exception as exc:
+                    status = f"Error: {exc}"
+                pending = None
+                pending_action = ""
+                parts = collect_partitions()
+                index = min(index, max(len(parts) - 1, 0))
+
+            roots = root_sources()
+            boot_map = persistent_mount_map()
+            h, w = stdscr.getmaxyx()
+            stdscr.erase()
+            stdscr.addnstr(0, 0, "diskman TUI", w - 1)
+            stdscr.addnstr(1, 0, nav, w - 1)
+            if pending:
+                stdscr.addnstr(2, 0, f"Result: {status} (running: {pending_action})", w - 1)
+            else:
+                stdscr.addnstr(2, 0, f"Result: {status}", w - 1)
+            stdscr.addnstr(3, 0, "-" * max(0, w - 1), w - 1)
+
+            for row, part in enumerate(parts[: max(0, h - 5)], start=4):
+                i = row - 4
+                if i >= len(parts):
+                    break
+                marker = ">" if i == index else " "
+                flags = []
+                if is_root_partition(part, roots):
+                    flags.append("ROOT")
+                if part.mounted:
+                    flags.append("MOUNTED")
+                    if is_mount_read_only(part):
+                        flags.append("RO")
+                if not is_mountable(part):
+                    flags.append("SKIP")
+                if part.is_luks:
+                    flags.append("LUKS_OPEN" if is_luks_open(part) else "LUKS_LOCKED")
+                if part.uuid and part.uuid in boot_map:
+                    flags.append("AUTOBOOT")
+                line = (
+                    f"{marker} {part.path:<16} {part.disk_kind:<3} {part.fstype or '-':<10} {part.size or '-':<7} "
+                    f"{smart_health(part):<8} {part.mountpoint or '-':<16} {','.join(flags) or '-'}"
+                )
+                stdscr.addnstr(row, 0, line, w - 1)
+
+            key = stdscr.getch()
+            if key == -1:
+                curses.napms(40)
+                continue
+
+            if key in (ord("q"), 27):
+                status = "Exiting..."
+                stdscr.addnstr(2, 0, f"Result: {status}", w - 1)
+                stdscr.refresh()
+                curses.napms(200)
+                break
+
+            if key in (curses.KEY_DOWN, ord("j")):
+                index = min(index + 1, max(len(parts) - 1, 0))
+                status = f"Selected {parts[index].path}" if parts else "Ready"
+            elif key in (curses.KEY_UP, ord("k")):
+                index = max(index - 1, 0)
+                status = f"Selected {parts[index].path}" if parts else "Ready"
+            elif key == ord("r"):
+                parts = collect_partitions()
+                status = "Refreshed"
+                index = min(index, max(len(parts) - 1, 0))
+            elif key == ord("a") and not pending:
+                try:
+                    require_root()
+                    pending = automount_async(base_dir=base_dir)
+                    pending_action = "automount"
+                    status = "Automount started"
+                except Exception as exc:
+                    status = f"Error: {exc}"
+            elif key == ord("m") and parts and not pending:
+                part = parts[index]
+                try:
+                    require_root()
+                    if part.mounted:
+                        pending = umount_partition_async(part, roots)
+                        pending_action = f"unmount {part.path}"
+                    else:
+                        passphrase = None
+                        if part.is_luks and not is_luks_open(part):
+                            status = "Enter LUKS passphrase"
+                            stdscr.addnstr(2, 0, f"Result: {status}", w - 1)
+                            stdscr.refresh()
+                            passphrase = _prompt_hidden(stdscr, min(h - 1, 3), 0, "LUKS passphrase: ")
+                        pending = mount_partition_async(part, base_dir, roots, passphrase)
+                        pending_action = f"mount {part.path}"
+                    status = f"Started {pending_action}"
+                except Exception as exc:
+                    status = f"Error: {exc}"
+                parts = collect_partitions()
+            elif key == ord("u") and parts and not pending:
+                part = parts[index]
+                try:
+                    require_root()
+                    if not part.is_luks:
+                        status = f"Not LUKS: {part.path}"
+                    elif is_luks_open(part):
+                        status = f"Already unlocked: {part.path}"
+                    else:
+                        status = "Enter LUKS passphrase"
+                        stdscr.addnstr(2, 0, f"Result: {status}", w - 1)
+                        stdscr.refresh()
+                        passphrase = _prompt_hidden(stdscr, min(h - 1, 3), 0, "LUKS passphrase: ")
+                        pending = unlock_luks_async(part, passphrase)
+                        pending_action = f"unlock {part.path}"
+                        status = f"Started {pending_action}"
+                except Exception as exc:
+                    status = f"Error: {exc}"
+            elif key == ord("l") and parts and not pending:
+                part = parts[index]
+                try:
+                    require_root()
+                    if not part.is_luks:
+                        status = f"Not LUKS: {part.path}"
+                    elif not is_luks_open(part):
+                        status = f"Already locked: {part.path}"
+                    else:
+                        pending = lock_luks_async(part)
+                        pending_action = f"lock {part.path}"
+                        status = f"Started {pending_action}"
+                except Exception as exc:
+                    status = f"Error: {exc}"
+            elif key == ord("p") and parts and not pending:
+                part = parts[index]
+                try:
+                    require_root()
+                    if not part.uuid:
+                        status = f"Error: missing UUID for {part.path}"
+                    elif part.uuid in boot_map:
+                        status = disable_persistent_mount(part)
+                    else:
+                        status = enable_persistent_mount(part, base_dir, roots)
+                except Exception as exc:
+                    status = f"Error: {exc}"
+                parts = collect_partitions()
+
+    curses.wrapper(tui)

diskman-0.2.1.dist-info/METADATA

@@ -0,0 +1,192 @@
+Metadata-Version: 2.4
+Name: diskman
+Version: 0.2.1
+Summary: CLI + TUI disk manager with SMART, LUKS, and non-blocking automount
+Home-page: https://github.com/gaffer/disk-manager
+Author: Gaffer
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/gaffer/disk-manager
+Project-URL: Repository, https://github.com/gaffer/disk-manager
+Project-URL: Issues, https://github.com/gaffer/disk-manager/issues
+Keywords: linux,disk,partition,mount,luks,smart,tui,cli
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: System Administrators
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: System :: Systems Administration
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=13.7.0
+Provides-Extra: binary
+Requires-Dist: pyinstaller>=6.0; extra == "binary"
+Provides-Extra: release
+Requires-Dist: build>=1.2.0; extra == "release"
+Requires-Dist: twine>=5.0.0; extra == "release"
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# diskman
+
+[![PyPI version](https://img.shields.io/pypi/v/diskman.svg)](https://pypi.org/project/diskman/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+
+**diskman** is a lightweight, terminal-first Linux disk and partition manager. It provides a powerful CLI and an interactive TUI for day-to-day storage administration, featuring SMART health monitoring, LUKS encryption support, and filesystem-aware automounting.
+
+---
+
+## 🚀 Key Features
+
+- **Dual Interface:** Full-featured Command Line Interface (CLI) and an interactive Terminal User Interface (TUI).
+- **Smart Automount:** Filesystem-aware mount options (e.g., `discard` for SSDs, UID/GID mapping for FAT/NTFS).
+- **LUKS Support:** Auto-detection, unlocking, and locking of encrypted partitions.
+- **Health Monitoring:** Real-time SMART health status visibility (via `smartmontools`).
+- **Safety First:** Automatically excludes root partitions from destructive operations and provides a **read-only fallback** if a writable mount fails.
+- **Non-Blocking Ops:** Asynchronous mount, unmount, and LUKS operations to keep the TUI responsive.
+- **Persistence:** Easily toggle reboot-persistent mounts via tagged `/etc/fstab` entries.
+- **System Integration:** Ready-to-use `systemd` service and timer for periodic automounting.
+
+---
+
+## 📦 Installation
+
+### From PyPI (Recommended)
+
+Install the latest stable version directly from PyPI:
+
+```bash
+python3 -m pip install --upgrade diskman
+```
+
+### From Source
+
+```bash
+git clone https://github.com/SoyalIslam/disk-manager.git
+cd disk-manager
+python3 -m pip install .
+```
+
+### Requirements
+
+- **OS:** Linux
+- **Python:** 3.9+
+- **System Tools:** `util-linux` (`lsblk`, `findmnt`, `mount`, `umount`)
+- **Optional Tools:**
+  - `cryptsetup` (for LUKS support)
+  - `smartmontools` (for SMART health monitoring)
+
+---
+
+## 🛠 Usage
+
+### CLI Reference
+
+| Command | Description |
+| :--- | :--- |
+| `diskman list` | List all partitions, filesystems, and mount status. |
+| `diskman tui` | Launch the interactive Terminal User Interface. |
+| `sudo diskman automount` | Auto-mount all available partitions (excluding root). |
+| `sudo diskman mount /dev/sdb1` | Mount a specific device (prompts for LUKS if needed). |
+| `sudo diskman umount /dev/sdb1` | Unmount a specific device. |
+| `sudo diskman luks-unlock /dev/sdb2` | Unlock a LUKS encrypted partition. |
+| `sudo diskman boot-add /dev/sdb1` | Enable reboot-persistent mount in `/etc/fstab`. |
+
+*Note: Operations that modify system state (mount/unmount/LUKS/fstab) require `sudo`.*
+
+### TUI Controls
+
+Launch with `diskman tui` (or `sudo diskman tui` for full functionality):
+
+- **`j` / `k`** or **Arrow Keys**: Navigate device list.
+- **`m`**: Mount or unmount the selected partition.
+- **`u` / `l`**: Unlock or lock a LUKS partition.
+- **`a`**: Trigger a background automount of all devices.
+- **`p`**: Toggle persistence (`/etc/fstab`) for the selected device.
+- **`r`**: Refresh the device list.
+- **`q`**: Exit.
+
+---
+
+## ⚙️ System Integration
+
+### Periodic Automount (systemd)
+
+You can automate mounting of external drives using the provided systemd units:
+
+1. **Install Units:**
+   ```bash
+   sudo install -Dm644 extras/systemd/diskman-automount.service /etc/systemd/system/
+   sudo install -Dm644 extras/systemd/diskman-automount.timer /etc/systemd/system/
+   ```
+
+2. **Enable Timer:**
+   ```bash
+   sudo systemctl daemon-reload
+   sudo systemctl enable --now diskman-automount.timer
+   ```
+
+---
+
+## 🏗 Development
+
+### Setup Environment
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -r requirements-dev.txt
+```
+
+### Build & Package
+
+```bash
+# Build distribution archives
+python3 -m build
+
+# Build standalone binary (via PyInstaller)
+./scripts/build_binary.sh
+```
+
+### GitHub Actions: Publish to PyPI
+
+This repo includes:
+
+- `.github/workflows/publish-pypi.yml`
+
+Set these repository secrets in GitHub:
+
+- `PYPI_API_TOKEN`
+- `TEST_PYPI_API_TOKEN`
+
+Workflow usage:
+
+1. Manual publish to TestPyPI:
+   - Actions -> `Publish Python Package` -> `Run workflow` -> target `testpypi`
+2. Manual publish to PyPI:
+   - Actions -> `Publish Python Package` -> `Run workflow` -> target `pypi`
+3. Auto publish to PyPI on tag:
+   - Push tag `vX.Y.Z` matching `pyproject.toml` version
+
+```bash
+git tag v0.2.1
+git push origin v0.2.1
+```
+
+---
+
+## 📄 License
+
+This project is licensed under the **MIT License**. See the [LICENSE](LICENSE) file for details.
+
+## 🤝 Contributing
+
+Contributions, issues, and feature requests are welcome! Feel free to check the [issues page](https://github.com/SoyalIslam/disk-manager/issues).

diskman-0.2.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+diskman/__init__.py,sha256=xJ2et1pA3q9-MEkIP1Cb8w1_Kgsp7XUCzIvDzn_Vup4,48
+diskman/cli.py,sha256=BeYhRRSDzrY82kr39ojm4IF34JvUfRFoxarBqa0hecU,8734
+diskman/core.py,sha256=LTCp_yvaTkAvMCvNdk7cO-G1bCDLZMWLB8DqlhitH-s,16379
+diskman/tui.py,sha256=OSh1FTdRYsS58jRlvSTzUBsaLwTC-2Hqmib36Fipjhw,8440
+diskman-0.2.1.dist-info/licenses/LICENSE,sha256=Ys5fmaQsRsB-8cJfy4e_CloHBDocl1gMixnZHOTpUfc,1063
+diskman-0.2.1.dist-info/METADATA,sha256=irlYbb8CAqPcJVWr4y12QXX9fdE9drKjYZtC86coY3Y,6167
+diskman-0.2.1.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+diskman-0.2.1.dist-info/entry_points.txt,sha256=VyD8ju6ss5UjWEKwVYWVX_IxBAlmqP9kIN2GcoKf5ls,45
+diskman-0.2.1.dist-info/top_level.txt,sha256=lbH0DpopZMDL5RBuoRLl1oO-_ZS-7UXIh16XoTpKyzQ,8
+diskman-0.2.1.dist-info/RECORD,,

diskman-0.2.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

diskman-0.2.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+diskman = diskman.cli:main

diskman-0.2.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Gaffer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

diskman-0.2.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+diskman