mountlet 0.2.0__py3-none-any.whl

mountlet/config_tools/setup_wizard.py

@@ -0,0 +1,225 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+import argparse
+import os
+import platform
+import shutil
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+from .. import core
+from ..settings import ensure_default_config_files
+from .shared import (
+    app_cache_dir,
+    app_config_dir,
+    app_config_file,
+    app_mounts_file,
+    app_state_dir,
+    default_config_path,
+    ensure_app_directories,
+    find_rclone,
+    read_remotes,
+    verify_remotes,
+)
+
+
+@dataclass
+class Readiness:
+    ready: bool
+    messages: list[str]
+    remotes: list[str]
+
+
+def _status(ok: bool, message: str) -> str:
+    return ("OK   " if ok else "TODO ") + message
+
+
+def _fuse_available() -> bool:
+    if platform.system() == "Windows":
+        return True
+    if shutil.which("fusermount3") or shutil.which("fusermount"):
+        return True
+    return False
+
+
+def _print_paths() -> None:
+    print("App files:")
+    print(f"  Settings: {app_config_file()}")
+    print(f"  Mount settings: {app_mounts_file()}")
+    print(f"  State:    {app_state_dir()}")
+    print(f"  Cache:    {app_cache_dir()}")
+    print(f"  Mounts:   {core.BASE_MOUNT_DIR}")
+    print(f"  rclone:   {default_config_path()}")
+
+
+def check_readiness() -> Readiness:
+    messages: list[str] = []
+    ensure_app_directories()
+    ensure_default_config_files()
+    core.ensure_base_mount_dir()
+    Path(core.BASE_MOUNT_DIR).mkdir(parents=True, exist_ok=True)
+
+    rclone_bin = find_rclone()
+    if not rclone_bin:
+        messages.append("Install rclone: sudo apt install rclone")
+
+    if not _fuse_available():
+        messages.append("Install FUSE: sudo apt install fuse3")
+
+    config_path = default_config_path()
+    if not config_path.exists():
+        messages.append(f"Create an rclone config: {config_path}")
+        remotes: list[str] = []
+    else:
+        remotes = read_remotes(config_path)
+        if not remotes:
+            messages.append("Add at least one cloud storage connection to rclone.")
+
+    return Readiness(ready=not messages, messages=messages, remotes=remotes)
+
+
+def ensure_ready_for_menu() -> bool:
+    readiness = check_readiness()
+    if readiness.ready:
+        return True
+
+    print("Mountlet needs a little setup first.")
+    print()
+    for message in readiness.messages:
+        print(f"- {message}")
+    print()
+    print("Run:")
+    print("  mountlet setup")
+    if find_rclone():
+        print()
+        print("If you still need to connect cloud storage, run:")
+        print("  mountlet setup --configure-rclone")
+    return False
+
+
+def _run_rclone_config(rclone_bin: str) -> int:
+    print()
+    print("Opening rclone setup. Follow the prompts to add a cloud storage remote.")
+    result = subprocess.run([rclone_bin, "config"])
+    return result.returncode
+
+
+def _next_steps(rclone_bin: str | None, fuse_ok: bool, remotes: list[str], failures: list[str]) -> list[str]:
+    steps: list[str] = []
+    if not rclone_bin:
+        steps.append("Install rclone: sudo apt install rclone")
+    if not fuse_ok:
+        steps.append("Install FUSE: sudo apt install fuse3")
+    if not remotes:
+        if rclone_bin:
+            steps.append("Add cloud storage: mountlet setup --configure-rclone")
+        else:
+            steps.append("After installing rclone, add cloud storage: mountlet setup --configure-rclone")
+    if failures:
+        steps.append("Reconnect credentials: mountlet reconnect --remote <name>")
+    return steps
+
+
+def setup_command(args: argparse.Namespace) -> int:
+    print("Mountlet setup")
+    print()
+
+    dirs = ensure_app_directories()
+    ensure_default_config_files()
+    core.ensure_base_mount_dir()
+    mount_dir = Path(core.BASE_MOUNT_DIR)
+    mount_dir.mkdir(parents=True, exist_ok=True)
+
+    print(_status(True, "Created user app folders."))
+    for path in dirs.values():
+        print(f"     {path}")
+    print(_status(mount_dir.exists(), f"Prepared mount folder: {mount_dir}"))
+
+    rclone_bin = find_rclone()
+    print(
+        _status(
+            bool(rclone_bin),
+            f"Found rclone: {rclone_bin}" if rclone_bin else "Install rclone. On Ubuntu: sudo apt install rclone",
+        )
+    )
+
+    fuse_ok = _fuse_available()
+    print(
+        _status(
+            fuse_ok,
+            "Found FUSE mount support." if fuse_ok else "Install FUSE. On Ubuntu: sudo apt install fuse3",
+        )
+    )
+
+    config_path = default_config_path()
+    config_exists = config_path.exists()
+    remotes = read_remotes(config_path) if config_exists else []
+
+    if not config_exists:
+        print(_status(False, f"No rclone config found at {config_path}"))
+    elif remotes:
+        print(_status(True, f"Found {len(remotes)} rclone remote(s)."))
+        for remote in remotes:
+            print(f"     {remote}")
+    else:
+        print(_status(False, f"No remotes found in {config_path}"))
+
+    if rclone_bin and args.configure_rclone and not remotes:
+        if _run_rclone_config(rclone_bin) != 0:
+            print("[!] rclone setup did not finish cleanly.")
+            return 1
+        remotes = read_remotes(config_path)
+        if remotes:
+            print(_status(True, f"Found {len(remotes)} rclone remote(s) after setup."))
+        else:
+            print(_status(False, "No remotes were added."))
+
+    if remotes and not args.skip_verify:
+        print()
+        print("Checking cloud access...")
+        results = verify_remotes(remotes)
+        failures = [name for name, (ok, _) in results.items() if not ok]
+    else:
+        failures = []
+
+    print()
+    _print_paths()
+    print()
+
+    ready = bool(rclone_bin and fuse_ok and remotes and not failures)
+    if ready:
+        print("Ready. Open the menu with:")
+        print("  mountlet")
+        return 0
+
+    print("A few things still need attention before mounting.")
+    for number, step in enumerate(_next_steps(rclone_bin, fuse_ok, remotes, failures), start=1):
+        print(f"  {number}. {step}")
+    return 1
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Prepare Mountlet for first use.")
+    parser.add_argument(
+        "--configure-rclone",
+        action="store_true",
+        help="Open rclone's setup flow if no remotes are configured.",
+    )
+    parser.add_argument(
+        "--skip-verify",
+        action="store_true",
+        help="Do not check cloud access during setup.",
+    )
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    return setup_command(parser.parse_args(argv))
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mountlet/config_tools/shared.py

@@ -0,0 +1,289 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+import configparser
+import datetime as _dt
+import os
+import platform
+import shutil
+import stat
+import subprocess
+import sys
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+APP_NAME = "mountlet"
+LEGACY_APP_NAMES = ("cloud-mount-manager",)
+
+
+def default_config_path() -> Path:
+    env_config = os.environ.get("RCLONE_CONFIG")
+    if env_config:
+        return Path(env_config).expanduser()
+    if platform.system() == "Windows":
+        base = Path(os.environ.get("APPDATA", Path.home() / "AppData" / "Roaming"))
+        return base / "rclone" / "rclone.conf"
+    return Path.home() / ".config" / "rclone" / "rclone.conf"
+
+
+def _platform_user_dir_for(kind: str, app_name: str) -> Path:
+    system = platform.system()
+    if system == "Windows":
+        env_name = "APPDATA" if kind == "config" else "LOCALAPPDATA"
+        fallback = Path.home() / "AppData" / ("Roaming" if kind == "config" else "Local")
+        return Path(os.environ.get(env_name, fallback)) / app_name
+    if system == "Darwin":
+        if kind == "cache":
+            return Path.home() / "Library" / "Caches" / app_name
+        return Path.home() / "Library" / "Application Support" / app_name
+
+    env_names = {
+        "config": "XDG_CONFIG_HOME",
+        "state": "XDG_STATE_HOME",
+        "cache": "XDG_CACHE_HOME",
+    }
+    defaults = {
+        "config": Path.home() / ".config",
+        "state": Path.home() / ".local" / "state",
+        "cache": Path.home() / ".cache",
+    }
+    base = Path(os.environ.get(env_names[kind], defaults[kind])).expanduser()
+    return base / app_name
+
+
+def _platform_user_dir(kind: str) -> Path:
+    return _platform_user_dir_for(kind, APP_NAME)
+
+
+def app_config_dir() -> Path:
+    return _platform_user_dir("config")
+
+
+def app_state_dir() -> Path:
+    return _platform_user_dir("state")
+
+
+def app_cache_dir() -> Path:
+    return _platform_user_dir("cache")
+
+
+def app_config_file() -> Path:
+    return app_config_dir() / "config.toml"
+
+
+def app_mounts_file() -> Path:
+    return app_config_dir() / "mounts.toml"
+
+
+def legacy_app_config_dirs() -> List[Path]:
+    return [_platform_user_dir_for("config", name) for name in LEGACY_APP_NAMES]
+
+
+def ensure_app_directories() -> Dict[str, Path]:
+    paths = {
+        "config": app_config_dir(),
+        "state": app_state_dir(),
+        "cache": app_cache_dir(),
+    }
+    for path in paths.values():
+        ensure_dir(path)
+    return paths
+
+
+def ensure_dir(path: Path) -> None:
+    path.mkdir(parents=True, exist_ok=True)
+
+
+def timestamp() -> str:
+    return _dt.datetime.now().strftime("%Y%m%d-%H%M%S")
+
+
+def backup_file(path: Path) -> Path:
+    backup = path.with_name(f"{path.name}.{timestamp()}.bak")
+    shutil.copy2(path, backup)
+    return backup
+
+
+def apply_permissions(path: Path) -> None:
+    if platform.system() != "Windows":
+        path.chmod(stat.S_IRUSR | stat.S_IWUSR)
+
+
+def copy_file(src: Path, dest: Path, *, backup: bool, dry_run: bool) -> Path | None:
+    if not src.exists():
+        return None
+    if dest.exists() and backup and not dry_run:
+        backup_file(dest)
+    if dry_run:
+        return dest
+    shutil.copy2(src, dest)
+    apply_permissions(dest)
+    return dest
+
+
+def find_client_secrets(default_dir: Path) -> List[Path]:
+    return sorted(Path(default_dir).glob("client_secret*.json"))
+
+
+_RCLONE_CACHED: str | None = None
+
+
+def find_rclone() -> str | None:
+    global _RCLONE_CACHED
+    if _RCLONE_CACHED is not None:
+        return _RCLONE_CACHED
+
+    candidates: List[Path] = []
+    env_path = os.environ.get("RCLONE_PATH")
+    if env_path:
+        candidates.append(Path(env_path).expanduser())
+
+    exe_name = "rclone.exe" if platform.system() == "Windows" else "rclone"
+    which_path = shutil.which(exe_name)
+    if which_path:
+        candidates.append(Path(which_path))
+
+    if platform.system() == "Windows":
+        candidates.append(Path("C:/Program Files/rclone/rclone.exe"))
+
+    for candidate in candidates:
+        if candidate and candidate.exists():
+            _RCLONE_CACHED = str(candidate)
+            return _RCLONE_CACHED
+
+    _RCLONE_CACHED = None
+    return None
+
+
+def run_rclone_version() -> str:
+    binary = find_rclone()
+    if not binary:
+        return "rclone binary not found. Install rclone or set RCLONE_PATH."
+    try:
+        output = subprocess.check_output([binary, "version"], stderr=subprocess.STDOUT, text=True)
+        return output.strip()
+    except subprocess.CalledProcessError as exc:
+        return f"rclone version check failed: {exc.output.strip() or exc}"
+
+
+def read_remotes(config_path: Path) -> List[str]:
+    parser = configparser.ConfigParser(interpolation=None)
+    try:
+        parser.read(config_path, encoding="utf-8")
+    except (OSError, configparser.Error):
+        return []
+    return [section for section in parser.sections()]
+
+
+def print_remote_list(remotes: List[str], source: Path, label: str = "Remotes discovered in") -> None:
+    if remotes:
+        print(f"[i] {label} {source}:")
+        for name in remotes:
+            print(f"    - {name}")
+    else:
+        print(f"[!] No remotes detected in {source}.")
+
+
+def resolve_remote_selection(config_path: Path, requested: List[str]) -> Tuple[List[str], List[str]]:
+    available = read_remotes(config_path)
+    if not requested:
+        return available, []
+
+    available_set = set(available)
+    selected: List[str] = []
+    missing: List[str] = []
+    for raw in requested:
+        name = raw.rstrip(":")
+        if name in available_set:
+            if name not in selected:
+                selected.append(name)
+        else:
+            missing.append(raw)
+    return selected, missing
+
+
+def verify_remotes(remotes: List[str]) -> Dict[str, Tuple[bool, str]]:
+    results: Dict[str, Tuple[bool, str]] = {}
+    if not remotes:
+        print("[!] No remotes available for verification.")
+        return results
+
+    binary = find_rclone()
+    if not binary:
+        print("[!] rclone executable not found; cannot verify remotes.")
+        for remote in remotes:
+            results[remote] = (False, "rclone binary missing")
+        return results
+
+    for remote in remotes:
+        result = subprocess.run(
+            [binary, "about", f"{remote}:"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        detail = result.stderr.strip() or result.stdout.strip()
+        success = result.returncode == 0
+        summary = (
+            detail.splitlines()[0]
+            if detail
+            else ("credentials accepted" if success else f"exit code {result.returncode}")
+        )
+        if success:
+            print(f"[✓] {remote}: {summary}")
+        else:
+            print(f"[!] {remote}: verification failed ({summary})")
+        results[remote] = (success, summary)
+    return results
+
+
+def reconnect_remotes(remotes: List[str], auto_confirm: bool) -> None:
+    if not remotes:
+        print("[!] No remotes available for reconnection.")
+        return
+    binary = find_rclone()
+    if not binary:
+        print("[!] rclone executable not found; cannot run reconnect.")
+        return
+    for remote in remotes:
+        remote_arg = f"{remote}:"
+        print(f"[>] Launching 'rclone config reconnect {remote_arg}' (Ctrl+C to skip)...")
+        sys.stdout.flush()
+        try:
+            cmd = [binary, "config", "reconnect", remote_arg]
+            if auto_confirm:
+                cmd.append("--auto-confirm")
+            result = subprocess.run(cmd, stdin=sys.stdin)
+        except KeyboardInterrupt:
+            print(f"[-] Reconnect for {remote_arg} skipped by user.")
+            continue
+        if result.returncode == 0:
+            print(f"[✓] {remote}: reconnect completed.")
+        else:
+            print(f"[!] {remote}: reconnect exited with code {result.returncode}.")
+            print(f"    Run manually: {' '.join(cmd)}")
+
+
+__all__ = [
+    "APP_NAME",
+    "LEGACY_APP_NAMES",
+    "default_config_path",
+    "app_config_dir",
+    "app_state_dir",
+    "app_cache_dir",
+    "app_config_file",
+    "app_mounts_file",
+    "legacy_app_config_dirs",
+    "ensure_app_directories",
+    "ensure_dir",
+    "copy_file",
+    "find_client_secrets",
+    "print_remote_list",
+    "run_rclone_version",
+    "resolve_remote_selection",
+    "verify_remotes",
+    "reconnect_remotes",
+    "find_rclone",
+    "read_remotes",
+]

mountlet/config_tools/verify_config.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+
+"""Verify access to rclone remotes, optionally auto-reconnecting failures."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from .shared import (
+    default_config_path,
+    print_remote_list,
+    resolve_remote_selection,
+    verify_remotes,
+    reconnect_remotes,
+)
+
+
+def verify_command(args: argparse.Namespace) -> int:
+    config_path = Path(args.config).expanduser().resolve() if args.config else default_config_path()
+    if not config_path.exists():
+        print(f"[!] Config file not found: {config_path}")
+        return 1
+
+    selected, missing = resolve_remote_selection(config_path, args.remote)
+    for name in missing:
+        print(f"[!] Remote not found in config: {name}")
+
+    if not selected:
+        print("[!] No remotes available for verification.")
+        return 1
+
+    print_remote_list(selected, config_path, label="Verifying remotes from")
+    results = verify_remotes(selected)
+    if not results:
+        return 1
+
+    failures = [name for name, (ok, _) in results.items() if not ok]
+
+    if args.auto_reconnect and failures:
+        print("[i] Attempting to reconnect failing remotes...")
+        reconnect_remotes(failures, args.reconnect_auto_confirm)
+        print_remote_list(failures, config_path, label="Re-checking remotes after reconnect from")
+        results.update(verify_remotes(failures))
+        failures = [name for name, (ok, _) in results.items() if not ok]
+
+    if failures:
+        for name in failures:
+            print(f"[!] {name}: still failing after verification.")
+        return 1
+
+    print("[✓] All selected remotes verified.")
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Verify rclone remotes and optionally auto-reconnect them.")
+    parser.add_argument(
+        "--config",
+        help="Config file to read remotes from (default: detected rclone path).",
+    )
+    parser.add_argument(
+        "--remote",
+        action="append",
+        default=[],
+        help="Specific remote to verify (repeatable). Defaults to all remotes in the config.",
+    )
+    parser.add_argument(
+        "--auto-reconnect",
+        dest="auto_reconnect",
+        action="store_true",
+        help="Attempt reconnect for failing remotes after verification.",
+    )
+    parser.add_argument(
+        "--no-reconnect-auto-confirm",
+        dest="reconnect_auto_confirm",
+        action="store_false",
+        help="When auto-reconnecting, do not pass --auto-confirm to rclone.",
+    )
+    parser.set_defaults(auto_reconnect=False, reconnect_auto_confirm=True)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    return verify_command(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())