@codebend3r/che 1.0.0

package/bin/drives/eject-all-drives.py

@@ -0,0 +1,203 @@
+#!/usr/bin/env python3
+"""📤 Eject all NAS volumes from /Volumes.
+
+Checks the primary mount as well as the duplicate ``<name>-1`` and IP-named
+mounts macOS creates when it re-mounts the same share twice. Stale placeholder
+directories left behind by a force-unmount are cleaned up with rmdir (sudo as a
+fallback).
+
+Also resets Finder's Favorite Servers and Recent Hosts lists, otherwise ejected
+NAS shares keep reappearing in the sidebar Locations after Finder relaunches.
+
+Usage:
+  eject-all-drives.py [--dry-run] [--only=NAME] [--no-force]
+                      [--no-clear-favorites] [--quiet]
+
+Options:
+  --dry-run              Show what would be unmounted, change nothing
+  --only=NAME            Only eject this drive (case-insensitive); skips the
+                         Favorite Servers reset, which would be over-broad
+  --no-force             Use 'diskutil unmount' instead of 'diskutil unmount force'
+  --no-clear-favorites   Don't reset Finder's Favorite Servers / Recent Hosts
+  --quiet                Only log unmounts and failures
+  --help                 Show help
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from utils import (
+    add_bool_flag,
+    build_parser,
+    info,
+    log,
+    note,
+    require_binary,
+    run,
+    run_cli,
+    success,
+    warning,
+)
+
+__version__ = "3.3.0"
+
+DRIVES: tuple[tuple[str, str], ...] = (
+    ("Meleys", "192.168.50.2"),
+    ("Vermithor", "192.168.50.3"),
+    ("Caraxes", "192.168.50.4"),
+    ("Syrax", "192.168.50.5"),
+    ("Vhagar", "192.168.50.6"),
+)
+
+
+def eject_volume(label: str, *, dry_run: bool, force: bool, quiet: bool) -> str:
+    """Unmount ``/Volumes/<label>``. Returns "ejected", "skipped" or "failed"."""
+    mount = Path("/Volumes") / label
+
+    if not mount.is_dir():
+        if not quiet:
+            info(f"  ⏭️  {label} — not mounted")
+        return "skipped"
+
+    if dry_run:
+        warning(f"  🪄 Would unmount {mount}")
+        return "ejected"
+
+    unmount_cmd = ["diskutil", "unmount"]
+    if force:
+        unmount_cmd.append("force")
+
+    log(f"  📤 Unmounting {mount}...")
+    completed = run([*unmount_cmd, str(mount)], check=False, capture=True)
+    if completed.returncode != 0:
+        warning(f"  ❌ Failed to unmount {mount}")
+        return "failed"
+
+    # A force-unmount can leave the placeholder directory behind. Try to clear
+    # it unprivileged first; fall back to sudo, and give up quietly if neither
+    # works, exactly as the shell version did.
+    if mount.is_dir():
+        try:
+            mount.rmdir()
+        except OSError:
+            run(["sudo", "rmdir", str(mount)], check=False, capture=True)
+
+    success(f"  ✅ {label} ejected")
+    return "ejected"
+
+
+def reset_finder_state(
+    selected: list[tuple[str, str]], *, clear_favorites: bool, only: str
+) -> None:
+    """Drop Finder's server-level entries so the sidebar stops resurrecting them."""
+    log("🪪 Asking Finder to drop any server-level entries...")
+    for name, _ in selected:
+        run(
+            [
+                "osascript",
+                "-e",
+                'tell application "Finder" to try',
+                "-e",
+                f'eject disk "{name}"',
+                "-e",
+                "end try",
+            ],
+            check=False,
+            capture=True,
+        )
+
+    # Skipped when --only is set: resetlist is all-or-nothing and would nuke
+    # the other drives' favorites too.
+    if not only and clear_favorites:
+        log("🧽 Resetting Finder Favorite Servers + Recent Hosts lists...")
+        for list_name in (
+            "com.apple.LSSharedFileList.FavoriteServers",
+            "com.apple.LSSharedFileList.RecentHosts",
+        ):
+            run(["sfltool", "resetlist", list_name], check=False, capture=True)
+
+    # SIGKILL specifically: a graceful quit lets Finder save its current
+    # sidebar state on the way out and restore the stale entries on relaunch.
+    log("🔄 Hard-killing Finder so it doesn't restore stale sidebar state...")
+    run(["killall", "-KILL", "Finder"], check=False, capture=True)
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser(
+        prog="eject-all-drives",
+        description="📤 Eject all NAS volumes from /Volumes.",
+    )
+    add_bool_flag(parser, "--dry-run", help="Show what would be unmounted, change nothing")
+    parser.add_argument(
+        "--only", default="", metavar="NAME", help="Only eject this drive (case-insensitive)"
+    )
+    add_bool_flag(
+        parser,
+        "--no-force",
+        dest="no_force",
+        allow_value=False,
+        help="Use 'diskutil unmount' instead of 'diskutil unmount force'",
+    )
+    add_bool_flag(
+        parser,
+        "--no-clear-favorites",
+        dest="no_clear_favorites",
+        allow_value=False,
+        help="Don't reset Finder's Favorite Servers / Recent Hosts lists",
+    )
+    add_bool_flag(parser, "--quiet", help="Only log unmounts and failures")
+    args = parser.parse_args(argv)
+
+    force = not args.no_force
+    clear_favorites = not args.no_clear_favorites
+
+    # Only gate on diskutil for a real run: the shell version's dry-run never
+    # invoked it, so previewing worked anywhere.
+    if not args.dry_run:
+        require_binary("diskutil", hint="This script is macOS-only.")
+
+    header_suffix = " 🌵 (dry run)" if args.dry_run else ""
+    note("═══════════════════════════════════════════")
+    note(f"📤  eject-all-drives{header_suffix}")
+    note("═══════════════════════════════════════════")
+
+    selected = [(n, ip) for n, ip in DRIVES if not args.only or n.lower() == args.only.lower()]
+    if args.only and not selected:
+        # Warn, but keep the shell version's exit code and control flow: an
+        # unknown --only printed a 0/0 summary and still exited 0.
+        warning(f"⚠️  No drive named '{args.only}'. Known: {', '.join(n for n, _ in DRIVES)}")
+
+    counts = {"ejected": 0, "skipped": 0, "failed": 0}
+
+    for name, ip in selected:
+        info(f"🐉 {name} ({ip})")
+        # macOS re-mounts of the same share land at "<name>-1" or at the IP.
+        for label in (name, f"{name}-1", ip):
+            counts[eject_volume(label, dry_run=args.dry_run, force=force, quiet=args.quiet)] += 1
+
+    print()
+    note("─────────────────────────────────────────────")
+
+    if args.dry_run:
+        success(f"🌵 Would eject:  {counts['ejected']}")
+        info(f"⏭️  Skipped:     {counts['skipped']} (not mounted)")
+        log("💡 Dry run complete. Nothing was actually ejected.")
+        return 0
+
+    success(f"✅ Ejected:  {counts['ejected']}")
+    info(f"⏭️  Skipped:  {counts['skipped']} (not mounted)")
+    if counts["failed"]:
+        warning(f"❌ Failed:   {counts['failed']}")
+        return 1
+
+    reset_finder_state(selected, clear_favorites=clear_favorites, only=args.only)
+    log("🎉 All clean! 🧹✨")
+    return 0
+
+
+if __name__ == "__main__":
+    run_cli(main)

package/bin/drives/mount-all-drives.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+"""💿 Mount all NAS drives over SMB via AppleScript's ``mount volume``.
+
+Using AppleScript (rather than ``mount_smbfs``) takes the same NetAuth path
+Finder does, so ``/Volumes/<name>`` is created automatically and Keychain
+credentials are used silently, with no Finder modals. Already-mounted drives
+are skipped. The share name is assumed to match the drive name, e.g.
+``//crivas@Meleys/Meleys`` → ``/Volumes/Meleys``.
+
+Usage:
+  mount-all-drives.py [--only=NAME] [--use-ip] [--quiet]
+
+Options:
+  --only=NAME   Only mount the drive with this name (case-insensitive)
+  --use-ip      Mount via //USER@IP/NAME instead of //USER@NAME/NAME
+  --quiet       Only log mounts and failures
+  --help        Show help
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from utils import (
+    add_bool_flag,
+    build_parser,
+    info,
+    log,
+    note,
+    require_binary,
+    run,
+    run_cli,
+    success,
+    warning,
+)
+
+__version__ = "4.1.0"
+
+SMB_USER = "crivas"
+
+# (name, ip) - the share name is assumed to match the drive name.
+DRIVES: tuple[tuple[str, str], ...] = (
+    ("Meleys", "192.168.50.2"),
+    ("Vermithor", "192.168.50.3"),
+    ("Caraxes", "192.168.50.4"),
+    ("Syrax", "192.168.50.5"),
+    ("Vhagar", "192.168.50.6"),
+)
+
+
+def is_mounted(name: str) -> bool:
+    """True when something is actually mounted at ``/Volumes/<name>``.
+
+    The shell version grepped ``mount`` output for `` on /Volumes/<name> (``;
+    ``os.path.ismount`` asks the kernel directly. The two agree for every
+    healthy mount. The one real difference: ``ismount`` lstats the mount root,
+    so on a wedged SMB mount it can block for the server timeout where reading
+    the mount table cannot.
+    """
+    return os.path.ismount(f"/Volumes/{name}")
+
+
+def mount_drive(name: str, host: str, *, quiet: bool) -> str:
+    """Mount one drive. Returns "mounted", "skipped" or "failed"."""
+    if is_mounted(name):
+        if not quiet:
+            info(f"⏭️  {name} — already mounted")
+        return "skipped"
+
+    url = f"smb://{SMB_USER}@{host}/{name}"
+    log(f"🔗 Mounting {name} ({url})...")
+
+    completed = run(
+        ["osascript", "-e", f'mount volume "{url}"'],
+        check=False,
+        capture=True,
+    )
+    if completed.returncode == 0:
+        success(f"  ✅ {name} mounted 🐉")
+        return "mounted"
+
+    warning(f"  ❌ mount failed for {url}")
+    stderr = (completed.stderr or "").strip()
+    if stderr:
+        warning(f"     {stderr}")
+    warning(f"     Check that Keychain has a password for '{SMB_USER}@{host}'.")
+    return "failed"
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser(
+        prog="mount-all-drives",
+        description="💿 Mount all NAS drives over SMB via AppleScript.",
+    )
+    parser.add_argument(
+        "--only", default="", metavar="NAME", help="Only mount this drive (case-insensitive)"
+    )
+    add_bool_flag(parser, "--use-ip", help="Mount via //USER@IP/NAME instead of //USER@NAME/NAME")
+    add_bool_flag(parser, "--quiet", help="Only log mounts and failures")
+    args = parser.parse_args(argv)
+
+    require_binary("osascript", hint="This script is macOS-only.")
+
+    note("═══════════════════════════════════════════")
+    note("💿  mount-all-drives")
+    note("═══════════════════════════════════════════")
+
+    counts = {"mounted": 0, "skipped": 0, "failed": 0}
+    matched = False
+
+    for name, ip in DRIVES:
+        if args.only and name.lower() != args.only.lower():
+            continue
+        matched = True
+        host = ip if args.use_ip else name
+        counts[mount_drive(name, host, quiet=args.quiet)] += 1
+
+    if args.only and not matched:
+        # Warn, but keep the shell version's exit code: an unknown --only
+        # printed a 0/0 summary and still exited 0.
+        warning(f"⚠️  No drive named '{args.only}'. Known: {', '.join(n for n, _ in DRIVES)}")
+
+    print()
+    note("─────────────────────────────────────────────")
+    success(f"✅ Mounted:  {counts['mounted']}")
+    info(f"⏭️  Skipped:  {counts['skipped']} (already mounted)")
+    if counts["failed"]:
+        warning(f"❌ Failed:   {counts['failed']}")
+        return 1
+
+    log("🎉 All drives are up! 🐉🐉🐉")
+    return 0
+
+
+if __name__ == "__main__":
+    run_cli(main)

package/bin/drives/ping-nas.py

@@ -0,0 +1,242 @@
+#!/usr/bin/env python3
+"""📡 Keep-alive pinger for the NAS drives.
+
+Each cycle pings every host and verifies it is still mounted under /Volumes.
+If a drive is reachable but the share has dropped off /Volumes (eject, network
+blip, sleep) it is silently remounted via AppleScript's ``mount volume`` using
+Keychain credentials, with no Finder modals.
+
+Usage:
+  ping-nas.py [--interval=SECONDS] [--ping-timeout=SECONDS] [--only=NAME]
+              [--no-remount] [--use-ip] [--once] [--quiet]
+
+Options:
+  --interval=N       Seconds between cycles (default: 300)
+  --ping-timeout=N   Per-host ping timeout in seconds (default: 2)
+  --only=NAME        Only ping the drive with this name (case-insensitive)
+  --no-remount       Detect-only: warn about missing mounts, don't remount
+  --use-ip           Remount via //USER@IP/NAME instead of //USER@NAME/NAME
+  --once             Run a single cycle and exit (useful from cron)
+  --quiet            Only log failures, remount attempts, and cycle summary
+  --help             Show help
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import signal
+import sys
+import time
+from pathlib import Path
+from types import FrameType
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from utils import (
+    add_bool_flag,
+    build_parser,
+    info,
+    log,
+    note,
+    run,
+    run_cli,
+    success,
+    warning,
+)
+
+__version__ = "3.3.0"
+
+SMB_USER = "crivas"
+
+DRIVES: tuple[tuple[str, str], ...] = (
+    ("Meleys", "192.168.50.2"),
+    ("Vermithor", "192.168.50.3"),
+    ("Caraxes", "192.168.50.4"),
+    ("Syrax", "192.168.50.5"),
+    ("Vhagar", "192.168.50.6"),
+)
+
+_cycle = 0
+
+
+def is_mounted(name: str) -> bool:
+    """True when something is actually mounted at ``/Volumes/<name>``."""
+    return os.path.ismount(f"/Volumes/{name}")
+
+
+def ping_host(ip: str, timeout: int) -> bool:
+    """One ICMP probe with a per-host timeout. macOS ``ping -t`` is seconds."""
+    completed = run(["ping", "-c", "1", "-t", str(timeout), ip], check=False, capture=True)
+    return completed.returncode == 0
+
+
+def remount_drive(name: str, host: str) -> bool:
+    """Remount one drive via AppleScript. True on success."""
+    url = f"smb://{SMB_USER}@{host}/{name}"
+    log(f"  🔗 Remounting {name} ({url})...")
+
+    completed = run(["osascript", "-e", f'mount volume "{url}"'], check=False, capture=True)
+    if completed.returncode == 0:
+        success(f"  ✅ {name} remounted 🐉")
+        return True
+
+    warning(f"  ❌ mount failed for {url}")
+    stderr = (completed.stderr or "").strip()
+    if stderr:
+        warning(f"     {stderr}")
+    warning(f"     Check that Keychain has a password for '{SMB_USER}@{host}'.")
+    return False
+
+
+def ping_all_nas(
+    active: list[tuple[str, str]],
+    *,
+    ping_timeout: int,
+    remount: bool,
+    use_ip: bool,
+    quiet: bool,
+) -> None:
+    """Run one full check cycle over the active drive list."""
+    global _cycle
+    _cycle += 1
+
+    unreachable = 0
+    unmounted = 0
+    remounted = 0
+    remount_failed = 0
+
+    if not quiet:
+        log(f"🔄 Cycle #{_cycle} — checking {len(active)} NAS drive(s)...")
+
+    for name, ip in active:
+        if not ping_host(ip, ping_timeout):
+            warning(f"  ❌ {name} ({ip}) — ping failed")
+            unreachable += 1
+            continue
+
+        if is_mounted(name):
+            if not quiet:
+                log(f"  ✅ 🐉 {name} ({ip}) — mounted")
+            continue
+
+        warning(f"  ⚠️  {name} ({ip}) — reachable but not mounted")
+        unmounted += 1
+
+        if remount:
+            if remount_drive(name, ip if use_ip else name):
+                remounted += 1
+            else:
+                remount_failed += 1
+
+    if unreachable == 0 and unmounted == 0:
+        if not quiet:
+            success(f"✨ All {len(active)} drive(s) responded and mounted 🎉")
+        return
+
+    parts = []
+    if unreachable:
+        parts.append(f"{unreachable} unreachable")
+    if remounted:
+        parts.append(f"{remounted} remounted")
+    if remount_failed:
+        parts.append(f"{remount_failed} remount-failed")
+    if not remount and unmounted:
+        parts.append(f"{unmounted} unmounted")
+    warning(f"⚠️  Cycle summary: {' '.join(parts)}")
+
+
+def _shutdown(signum: int, frame: FrameType | None) -> None:
+    """Exit 0 on Ctrl-C, matching the shell version's INT/TERM trap."""
+    print()
+    info(f"👋 Stopping keep-alive pinger after {_cycle} cycle(s).")
+    sys.exit(0)
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser(
+        prog="ping-nas",
+        description="📡 Keep-alive pinger for the NAS drives.",
+        epilog=(
+            "Each cycle pings every host and verifies it is still mounted under\n"
+            "/Volumes. A drive that is reachable but has dropped off /Volumes is\n"
+            f"silently remounted via AppleScript as '{SMB_USER}' using Keychain\n"
+            "credentials, with no Finder modals."
+        ),
+    )
+    # --interval and --ping-timeout stay strings so the shell version's own
+    # message survives; `type=int` would let argparse own the failure first.
+    parser.add_argument(
+        "--interval", default="300", metavar="N", help="Seconds between cycles (default: 300)"
+    )
+    parser.add_argument(
+        "--ping-timeout",
+        dest="ping_timeout",
+        default="2",
+        metavar="N",
+        help="Per-host ping timeout in seconds (default: 2)",
+    )
+    parser.add_argument(
+        "--only", default="", metavar="NAME", help="Only ping this drive (case-insensitive)"
+    )
+    add_bool_flag(
+        parser,
+        "--no-remount",
+        dest="no_remount",
+        allow_value=False,
+        help="Detect-only: warn about missing mounts, don't remount",
+    )
+    add_bool_flag(
+        parser,
+        "--use-ip",
+        dest="use_ip",
+        help="Remount via //USER@IP/NAME instead of //USER@NAME/NAME",
+    )
+    add_bool_flag(parser, "--once", help="Run a single cycle and exit (useful from cron)")
+    add_bool_flag(parser, "--quiet", help="Only log failures, remount attempts, and cycle summary")
+    args = parser.parse_args(argv)
+
+    values: dict[str, int] = {}
+    for flag, raw in (("--interval", args.interval), ("--ping-timeout", args.ping_timeout)):
+        if not re.fullmatch(r"[0-9]+", raw) or int(raw) < 1:
+            warning(f"❌ {flag} must be a positive integer (got: {raw})")
+            return 1
+        values[flag] = int(raw)
+    interval = values["--interval"]
+    ping_timeout = values["--ping-timeout"]
+
+    active = [(n, ip) for n, ip in DRIVES if not args.only or n.lower() == args.only.lower()]
+    if not active:
+        warning(f"❌ No drives matched --only={args.only}")
+        return 1
+
+    signal.signal(signal.SIGINT, _shutdown)
+    signal.signal(signal.SIGTERM, _shutdown)
+
+    note("═══════════════════════════════════════════")
+    note("📡  ping-nas")
+    note("═══════════════════════════════════════════")
+
+    cycle_kwargs = {
+        "ping_timeout": ping_timeout,
+        "remount": not args.no_remount,
+        "use_ip": args.use_ip,
+        "quiet": args.quiet,
+    }
+
+    if args.once:
+        ping_all_nas(active, **cycle_kwargs)
+        return 0
+
+    info(
+        f"🚀 Keep-alive pinger started for {len(active)} NAS "
+        f"(every {interval}s). Press Ctrl-C to stop."
+    )
+
+    while True:
+        ping_all_nas(active, **cycle_kwargs)
+        time.sleep(interval)
+
+
+if __name__ == "__main__":
+    run_cli(main)