mountlet 0.2.0__py3-none-any.whl

mountlet/__init__.py

@@ -0,0 +1,5 @@
+"""Mountlet package."""
+
+__version__ = "0.2.0"
+
+__all__ = ["__version__"]

mountlet/cli.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+import sys
+from collections.abc import Callable
+
+from . import __version__
+from . import tui
+from .config_tools import export_config, import_config, path_config, reconnect_config, setup_wizard, verify_config
+
+Command = Callable[[list[str] | None], int | None]
+
+
+def run_menu(argv: list[str] | None = None) -> int:
+    if argv:
+        print("The menu command does not accept options.", file=sys.stderr)
+        return 2
+    if not setup_wizard.ensure_ready_for_menu():
+        return 1
+    result = tui.main()
+    return int(result or 0)
+
+
+def run_path(argv: list[str] | None = None) -> int:
+    return int(path_config.main(argv) or 0)
+
+
+def run_setup(argv: list[str] | None = None) -> int:
+    return int(setup_wizard.main(argv) or 0)
+
+
+def run_verify(argv: list[str] | None = None) -> int:
+    return int(verify_config.main(argv) or 0)
+
+
+def run_reconnect(argv: list[str] | None = None) -> int:
+    return int(reconnect_config.main(argv) or 0)
+
+
+def run_export(argv: list[str] | None = None) -> int:
+    return int(export_config.main(argv) or 0)
+
+
+def run_import(argv: list[str] | None = None) -> int:
+    return int(import_config.main(argv) or 0)
+
+
+def run_tray(argv: list[str] | None = None) -> int:
+    from . import tray
+
+    return int(tray.main(argv) or 0)
+
+
+COMMANDS: dict[str, tuple[str, Command]] = {
+    "menu": ("Open the interactive mount menu.", run_menu),
+    "tray": ("Open the desktop tray app.", run_tray),
+    "setup": ("Prepare the app for first use.", run_setup),
+    "path": ("Show config, state, cache, and rclone paths.", run_path),
+    "verify": ("Check whether configured remotes are reachable.", run_verify),
+    "reconnect": ("Refresh credentials for one or more remotes.", run_reconnect),
+    "export": ("Export an rclone configuration backup bundle.", run_export),
+    "import": ("Import an rclone configuration backup bundle.", run_import),
+}
+
+ALIASES = {
+    "paths": "path",
+    "tui": "menu",
+}
+
+
+def print_help() -> None:
+    print("mountlet")
+    print()
+    print("Usage:")
+    print("  mountlet")
+    print("  mountlet <command> [options]")
+    print()
+    print("Commands:")
+    for name, (description, _) in COMMANDS.items():
+        print(f"  {name:<10} {description}")
+    print()
+    print("Run 'mountlet <command> --help' for command-specific options.")
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = list(sys.argv[1:] if argv is None else argv)
+    if args and args[0] in {"--version", "-V"}:
+        print(f"mountlet {__version__}")
+        return 0
+    if not args:
+        return run_menu()
+
+    command_name = args.pop(0)
+    if command_name in {"-h", "--help", "help"}:
+        if command_name == "help" and args:
+            command_name = ALIASES.get(args[0], args[0])
+            command = COMMANDS.get(command_name)
+            if command:
+                return int(command[1](["--help"]) or 0)
+        print_help()
+        return 0
+
+    command_name = ALIASES.get(command_name, command_name)
+    command = COMMANDS.get(command_name)
+    if not command:
+        print(f"[!] Unknown command: {command_name}", file=sys.stderr)
+        print_help()
+        return 2
+
+    result = command[1](args)
+    return int(result or 0)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mountlet/config_tools/export_config.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+
+"""Export the current rclone configuration and secrets into a directory."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from .shared import (
+    copy_file,
+    default_config_path,
+    find_client_secrets,
+    ensure_dir,
+    print_remote_list,
+    read_remotes,
+)
+
+
+def export_bundle(args: argparse.Namespace) -> int:
+    source_conf = Path(args.config).expanduser().resolve() if args.config else default_config_path()
+    if not source_conf.exists():
+        print(f"[!] Config file not found: {source_conf}")
+        return 1
+
+    destination = Path(args.destination).expanduser().resolve()
+    ensure_dir(destination)
+
+    copied_conf = copy_file(source_conf, destination / source_conf.name, backup=args.backup, dry_run=args.dry_run)
+    if copied_conf:
+        action = "would copy" if args.dry_run else "copied"
+        print(f"[*] {action} {source_conf} -> {copied_conf}")
+
+    secrets: list[Path] = []
+    for secret in args.client_secret:
+        path = Path(secret).expanduser().resolve()
+        if path.exists():
+            secrets.append(path)
+        else:
+            print(f"[!] client secret missing: {path}")
+
+    if args.auto_discover_secrets:
+        for item in find_client_secrets(source_conf.parent):
+            if item not in secrets:
+                secrets.append(item)
+
+    for secret in secrets:
+        dest_secret = destination / secret.name
+        copied_secret = copy_file(secret, dest_secret, backup=args.backup, dry_run=args.dry_run)
+        if copied_secret:
+            action = "would copy" if args.dry_run else "copied"
+            print(f"[*] {action} {secret} -> {copied_secret}")
+
+    if not args.dry_run:
+        remotes = read_remotes(source_conf)
+        print_remote_list(remotes, source_conf)
+        print(f"[i] Bundle ready at {destination}")
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Export rclone configuration and secrets into a directory.")
+    parser.add_argument("destination", help="Directory where the bundle will be written.")
+    parser.add_argument(
+        "--config",
+        help="Override source rclone.conf (default: detected path).",
+    )
+    parser.add_argument(
+        "--client-secret",
+        action="append",
+        default=[],
+        help="Explicit client_secret JSON files to include (repeatable).",
+    )
+    parser.add_argument(
+        "--no-auto-discover",
+        dest="auto_discover_secrets",
+        action="store_false",
+        help="Disable searching for client_secret*.json next to the config file.",
+    )
+    parser.add_argument(
+        "--no-backup",
+        dest="backup",
+        action="store_false",
+        help="Do not backup existing files in destination.",
+    )
+    parser.add_argument("--dry-run", action="store_true", help="Preview without copying.")
+    parser.set_defaults(auto_discover_secrets=True, backup=True)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    return export_bundle(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mountlet/config_tools/import_config.py

@@ -0,0 +1,164 @@
+#!/usr/bin/env python3
+
+"""Import an rclone configuration bundle into the active environment."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from .shared import (
+    copy_file,
+    default_config_path,
+    ensure_dir,
+    find_client_secrets,
+    print_remote_list,
+    read_remotes,
+    run_rclone_version,
+    verify_remotes,
+    reconnect_remotes,
+)
+
+
+def import_bundle(args: argparse.Namespace) -> int:
+    target_conf = default_config_path()
+    target_dir = target_conf.parent
+
+    if args.target_dir:
+        target_dir = Path(args.target_dir).expanduser().resolve()
+        target_conf = target_dir / target_conf.name
+
+    ensure_dir(target_dir)
+
+    src_config = Path(args.config).expanduser().resolve()
+    if not src_config.exists():
+        print(f"[!] Config file not found: {src_config}")
+        return 1
+
+    copied_conf = copy_file(src_config, target_conf, backup=args.backup, dry_run=args.dry_run)
+    if copied_conf:
+        action = "would copy" if args.dry_run else "copied"
+        print(f"[*] {action} {src_config} -> {copied_conf}")
+
+    secrets: list[Path] = []
+    for secret in args.client_secret:
+        secret_path = Path(secret).expanduser().resolve()
+        if secret_path.exists():
+            secrets.append(secret_path)
+        else:
+            print(f"[!] client secret missing: {secret_path}")
+
+    if args.auto_discover_secrets:
+        for item in find_client_secrets(src_config.parent):
+            if item not in secrets:
+                secrets.append(item)
+
+    for secret in secrets:
+        dest_secret = target_dir / secret.name
+        copied_secret = copy_file(secret, dest_secret, backup=args.backup, dry_run=args.dry_run)
+        if copied_secret:
+            action = "would copy" if args.dry_run else "copied"
+            print(f"[*] {action} {secret} -> {copied_secret}")
+
+    reference_config = src_config if args.dry_run else target_conf
+    remotes = read_remotes(reference_config)
+    print_remote_list(remotes, reference_config)
+
+    if args.dry_run:
+        return 0
+
+    version_info = run_rclone_version()
+    print(f"[*] rclone check: {version_info}")
+    if not remotes or args.skip_verify:
+        if remotes and args.skip_verify:
+            print("[i] Verification skipped. Run 'mountlet verify' when ready.")
+        elif remotes:
+            print("[i] No remotes found to verify.")
+        return 0
+
+    print("[i] Verifying imported remotes...")
+    results = verify_remotes(remotes)
+    failures = [name for name, (ok, _) in results.items() if not ok]
+
+    if failures and args.verify_auto_reconnect:
+        print("[i] Attempting to reconnect failing remotes...")
+        reconnect_remotes(failures, args.reconnect_auto_confirm)
+        print_remote_list(failures, reference_config, 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 import.")
+        return 1
+
+    print("[✓] All imported remotes verified.")
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Import an rclone configuration and credentials bundle.")
+    parser.add_argument(
+        "--config",
+        required=True,
+        help="Path to the rclone.conf file to import.",
+    )
+    parser.add_argument(
+        "--client-secret",
+        action="append",
+        default=[],
+        help="Path to a client_secret JSON file to import (repeatable).",
+    )
+    parser.add_argument(
+        "--no-auto-discover",
+        dest="auto_discover_secrets",
+        action="store_false",
+        help="Disable searching for client_secret*.json next to the config file.",
+    )
+    parser.add_argument(
+        "--target-dir",
+        help="Override destination directory (default: OS rclone directory).",
+    )
+    parser.add_argument(
+        "--no-backup",
+        dest="backup",
+        action="store_false",
+        help="Do not backup existing files.",
+    )
+    parser.add_argument("--dry-run", action="store_true", help="Preview without copying.")
+    parser.add_argument(
+        "--no-verify",
+        dest="skip_verify",
+        action="store_true",
+        help="Skip verification after import.",
+    )
+    parser.add_argument(
+        "--verify-auto-reconnect",
+        dest="verify_auto_reconnect",
+        action="store_true",
+        help="After import verification, run reconnect for failing remotes.",
+    )
+    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_discover_secrets=True,
+        backup=True,
+        skip_verify=False,
+        verify_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 import_bundle(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mountlet/config_tools/path_config.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+
+"""Print Mountlet and rclone path locations."""
+
+from __future__ import annotations
+
+import argparse
+
+from .shared import (
+    app_cache_dir,
+    app_config_dir,
+    app_config_file,
+    app_mounts_file,
+    app_state_dir,
+    default_config_path,
+    ensure_app_directories,
+)
+from ..settings import ensure_default_config_files
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Print user-specific configuration and data paths.")
+    parser.add_argument("--ensure", action="store_true", help="Create Mountlet user directories.")
+    parser.add_argument("--rclone-config", action="store_true", help="Print only the rclone config path.")
+    parser.add_argument(
+        "--app-config",
+        action="store_true",
+        help="Print only the Mountlet config file path.",
+    )
+    parser.add_argument("--state", action="store_true", help="Print only the Mountlet state directory.")
+    parser.add_argument("--cache", action="store_true", help="Print only the Mountlet cache directory.")
+    parser.add_argument(
+        "--mounts-config",
+        action="store_true",
+        help="Print only the per-remote mount config file path.",
+    )
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    if args.ensure:
+        ensure_app_directories()
+        ensure_default_config_files()
+
+    selected = {
+        "rclone_config": args.rclone_config,
+        "app_config": args.app_config,
+        "mounts_config": args.mounts_config,
+        "state": args.state,
+        "cache": args.cache,
+    }
+    show_all = not any(selected.values())
+    paths = [
+        ("rclone config", "rclone_config", default_config_path()),
+        ("app config", "app_config", app_config_file()),
+        ("mounts config", "mounts_config", app_mounts_file()),
+        ("app config directory", "app_config", app_config_dir()),
+        ("state directory", "state", app_state_dir()),
+        ("cache directory", "cache", app_cache_dir()),
+    ]
+    for label, key, path in paths:
+        if show_all or selected[key]:
+            print(f"{label}: {path}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mountlet/config_tools/reconnect_config.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+
+"""Force rclone to reconnect selected remotes."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from .shared import (
+    default_config_path,
+    print_remote_list,
+    resolve_remote_selection,
+    reconnect_remotes,
+)
+
+
+def reconnect_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 reconnection.")
+        return 1
+
+    print_remote_list(selected, config_path, label="Reconnecting remotes from")
+    reconnect_remotes(selected, args.reconnect_auto_confirm)
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Run 'rclone config reconnect' for selected remotes.")
+    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 reconnect (repeatable). Defaults to all remotes in the config.",
+    )
+    parser.add_argument(
+        "--no-auto-confirm",
+        dest="reconnect_auto_confirm",
+        action="store_false",
+        help="Do not pass --auto-confirm to reconnect commands.",
+    )
+    parser.set_defaults(reconnect_auto_confirm=True)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    return reconnect_command(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())