@codebend3r/che 1.0.0 → 1.2.0

package/bin/doctor.py

@@ -0,0 +1,220 @@
+"""``che doctor``: every check on the install, as data first and a table second.
+
+:func:`diagnose` collects the checks as :class:`Check` records, so the table
+and ``--json`` can never disagree. Nothing here changes anything; each problem
+comes with the command that fixes it.
+
+Library module: no shebang, not executable.
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+
+import shellgen
+from art import print_logo
+from commands import REPO, VERSION, all_commands, required_binaries
+from machine import (
+    INSTALL_HINTS,
+    PYTHON_HINT,
+    SHELLS,
+    ShellSpec,
+    default_shell_selection,
+    find_python,
+    load_record,
+    login_shell,
+    python_ok,
+    shim_on_path,
+    shim_path,
+    tildify,
+    update_command,
+    version_text,
+)
+from rcfile import ALIAS, find_block, find_legacy, find_shadowing, read_rc
+from tui import palette
+from utils import add_bool_flag, build_parser, note, success, warning
+
+OK, WARN, FAIL = "ok", "warn", "fail"
+
+ALIAS_FIX = "the alias wins at the prompt; run `\\name` for the wrapper, or remove the alias"
+
+
+@dataclass(frozen=True)
+class Check:
+    """One line of the report: what was checked, how it stands, and the fix."""
+
+    name: str
+    status: str  # OK, WARN or FAIL
+    detail: str
+    fix: str = ""
+    # A passing check that is noise unless asked for, like a tool that is present.
+    quiet: bool = False
+
+    def to_json(self) -> dict[str, str]:
+        return {"name": self.name, "status": self.status, "detail": self.detail, "fix": self.fix}
+
+
+def diagnose() -> list[Check]:
+    """Collect every check as data, so both the table and --json use one source."""
+    record = load_record()
+
+    python, version = find_python()
+    checks = [
+        Check(
+            "python",
+            OK if python_ok(version) else FAIL,
+            f"{version_text(version)} ({python})",
+            PYTHON_HINT,
+        ),
+        # Informational: doctor runs from this repo's own che.py, so a repo
+        # without one could never have got this far.
+        Check("repo", OK, str(REPO)),
+    ]
+
+    try:
+        stale = shellgen.sync_generated(dry_run=True)
+    except ValueError as exc:
+        checks.append(Check("generated files", WARN, str(exc), "restore the markers in README.md"))
+    else:
+        detail = f"{len(stale)} out of date: {', '.join(map(str, stale))}" if stale else "current"
+        checks.append(Check("generated files", WARN if stale else OK, detail, "che install"))
+
+    recorded = record.version if record else ""
+    checks.append(
+        Check(
+            "install record",
+            OK if recorded == VERSION else (WARN if record else FAIL),
+            f"config {recorded or 'missing'} vs che {VERSION}",
+            "che install",
+        )
+    )
+
+    # Only the shells this install actually targets. Reporting on every shell
+    # present would flag ~/.profile as "missing" on any machine with /bin/sh,
+    # which is every machine.
+    watched = {*(record.shells if record else default_shell_selection()), login_shell()}
+    for spec in SHELLS.values():
+        if spec.name in watched:
+            checks += [_rc_check(spec, rc_file) for rc_file in spec.rc_files]
+
+    shim = shim_path()
+    if shim.exists() and shim_on_path():
+        checks.append(Check("che on PATH", OK, str(shim)))
+    elif shim.exists():
+        detail = f"{shim} (PATH picks it up on your next shell)"
+        checks.append(Check("che on PATH", WARN, detail, f"exec {login_shell() or 'zsh'}"))
+    else:
+        checks.append(Check("che on PATH", WARN, "not installed", "che install"))
+
+    for binary, users in required_binaries().items():
+        found = shutil.which(binary)
+        used_by = ", ".join(users[:3]) + (f" +{len(users) - 3}" if len(users) > 3 else "")
+        checks.append(
+            Check(
+                f"tool: {binary}",
+                OK if found else WARN,
+                found or f"missing - needed by {used_by}",
+                INSTALL_HINTS.get(binary, ""),
+                quiet=True,
+            )
+        )
+
+    missing = [
+        command.name for command in all_commands() if command.script and not command.path.exists()
+    ]
+    checks.append(
+        Check(
+            "scripts",
+            OK if not missing else FAIL,
+            f"{len(all_commands())} commands"
+            + (f", missing: {', '.join(missing)}" if missing else ""),
+            update_command(),
+        )
+    )
+
+    return checks
+
+
+def _rc_check(spec: ShellSpec, rc_file: Path) -> Check:
+    """Whether ``rc_file`` has the block, and whatever in it competes with the block."""
+    name = f"{spec.name}: {tildify(rc_file)}"
+    try:
+        text = read_rc(rc_file)
+    except OSError as exc:
+        return Check(name, FAIL, f"unreadable ({exc.strerror or exc})", "make it readable")
+
+    has_block = find_block(text) is not None
+    legacy = find_legacy(text)
+    shadowing = find_shadowing(text)
+
+    if has_block:
+        status = WARN if (legacy or shadowing) else OK
+    else:
+        status = WARN if spec.opt_in else FAIL
+
+    detail = "block installed" if has_block else "no che block"
+    if legacy:
+        detail += f", {len(legacy)} legacy wrappers"
+    if shadowing:
+        detail += ", shadowed: " + ", ".join(f"{wrapper} ({how})" for wrapper, how in shadowing[:3])
+
+    if legacy:
+        fix = "che install --replace-legacy"
+    elif any(how == ALIAS for _, how in shadowing):
+        fix = ALIAS_FIX
+    elif shadowing:
+        fix = "move your definition above the che block"
+    else:
+        fix = "che install"
+    return Check(name, status, detail, fix)
+
+
+def doctor(*, as_json: bool = False, verbose: bool = False) -> int:
+    checks = diagnose()
+    failures = sum(1 for check in checks if check.status == FAIL)
+
+    if as_json:
+        payload = {"version": VERSION, "checks": [check.to_json() for check in checks]}
+        print(json.dumps(payload, indent=2))
+        return 1 if failures else 0
+
+    colors = palette()
+    marks = {
+        OK: f"{colors.green}✓{colors.reset}",
+        WARN: f"{colors.yellow}!{colors.reset}",
+        FAIL: f"{colors.red}✗{colors.reset}",
+    }
+    print_logo(f"doctor - che {VERSION}")
+    width = max(len(check.name) for check in checks) + 2
+
+    for check in checks:
+        if check.status == OK and check.quiet and not verbose:
+            continue
+        print(
+            f"  {marks[check.status]} {check.name:<{width}} {colors.grey}{check.detail}{colors.reset}"
+        )
+        if check.status != OK and check.fix:
+            print(f"    {colors.grey}→ {check.fix}{colors.reset}")
+
+    warnings = sum(1 for check in checks if check.status == WARN)
+    print()
+    if failures:
+        warning(f"{failures} problem(s), {warnings} warning(s).")
+    elif warnings:
+        note(f"All good, with {warnings} warning(s).")
+    else:
+        success("Everything checks out.")
+    return 1 if failures else 0
+
+
+def doctor_main(argv: list[str] | None = None) -> int:
+    parser = build_parser(
+        prog="che doctor", description="🩺 Check the install and everything it depends on."
+    )
+    add_bool_flag(parser, "--json", help="Machine-readable output")
+    add_bool_flag(parser, "--verbose", help="Include checks that passed")
+    args = parser.parse_args(argv)
+    return doctor(as_json=args.json, verbose=args.verbose)

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

@@ -30,12 +30,15 @@ from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
 
+from nas import NasDrive, select_drives, warn_unknown_drive
 from utils import (
     add_bool_flag,
     build_parser,
+    dry_run_complete,
+    footer_rule,
+    heading,
     info,
     log,
-    note,
     require_binary,
     run,
     run_cli,
@@ -45,14 +48,6 @@ from utils import (
 
 __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"."""
@@ -90,19 +85,17 @@ def eject_volume(label: str, *, dry_run: bool, force: bool, quiet: bool) -> str:
     return "ejected"
 
 
-def reset_finder_state(
-    selected: list[tuple[str, str]], *, clear_favorites: bool, only: str
-) -> None:
+def reset_finder_state(selected: list[NasDrive], *, reset_lists: bool) -> 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:
+    for drive in selected:
         run(
             [
                 "osascript",
                 "-e",
                 'tell application "Finder" to try',
                 "-e",
-                f'eject disk "{name}"',
+                f'eject disk "{drive.name}"',
                 "-e",
                 "end try",
             ],
@@ -110,9 +103,7 @@ def reset_finder_state(
             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:
+    if reset_lists:
         log("🧽 Resetting Finder Favorite Servers + Recent Hosts lists...")
         for list_name in (
             "com.apple.LSSharedFileList.FavoriteServers",
@@ -138,54 +129,44 @@ def main(argv: list[str] | None = None) -> int:
     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("═══════════════════════════════════════════")
+    heading("📤  eject-all-drives", dry_run=args.dry_run)
 
-    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)}")
+    selected = select_drives(args.only)
+    if not selected:
+        warn_unknown_drive(args.only)
 
+    force = not args.no_force
     counts = {"ejected": 0, "skipped": 0, "failed": 0}
 
-    for name, ip in selected:
-        info(f"🐉 {name} ({ip})")
+    for drive in selected:
+        info(f"🐉 {drive.name} ({drive.ip})")
         # macOS re-mounts of the same share land at "<name>-1" or at the IP.
-        for label in (name, f"{name}-1", ip):
+        for label in (drive.name, f"{drive.name}-1", drive.ip):
             counts[eject_volume(label, dry_run=args.dry_run, force=force, quiet=args.quiet)] += 1
 
-    print()
-    note("─────────────────────────────────────────────")
+    footer_rule()
 
     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.")
+        dry_run_complete("ejected")
         return 0
 
     success(f"✅ Ejected:  {counts['ejected']}")
@@ -194,7 +175,9 @@ def main(argv: list[str] | None = None) -> int:
         warning(f"❌ Failed:   {counts['failed']}")
         return 1
 
-    reset_finder_state(selected, clear_favorites=clear_favorites, only=args.only)
+    # The lists are left alone under --only: resetlist is all-or-nothing and
+    # would nuke the other drives' favorites too.
+    reset_finder_state(selected, reset_lists=not args.only and not args.no_clear_favorites)
     log("🎉 All clean! 🧹✨")
     return 0
 

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

@@ -19,20 +19,20 @@ Options:
 
 from __future__ import annotations
 
-import os
 import sys
 from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
 
+from nas import is_mounted, mount_smb, select_drives, smb_url, warn_unknown_drive
 from utils import (
     add_bool_flag,
     build_parser,
+    footer_rule,
+    heading,
     info,
     log,
-    note,
     require_binary,
-    run,
     run_cli,
     success,
     warning,
@@ -40,29 +40,6 @@ from utils import (
 
 __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"."""
@@ -71,24 +48,12 @@ def mount_drive(name: str, host: str, *, quiet: bool) -> str:
             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"
+    log(f"🔗 Mounting {name} ({smb_url(name, host)})...")
+    if not mount_smb(name, host):
+        return "failed"
 
-    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"
+    success(f"  ✅ {name} mounted 🐉")
+    return "mounted"
 
 
 def main(argv: list[str] | None = None) -> int:
@@ -105,27 +70,18 @@ def main(argv: list[str] | None = None) -> int:
 
     require_binary("osascript", hint="This script is macOS-only.")
 
-    note("═══════════════════════════════════════════")
-    note("💿  mount-all-drives")
-    note("═══════════════════════════════════════════")
+    heading("💿  mount-all-drives")
+
+    selected = select_drives(args.only)
+    if not selected:
+        warn_unknown_drive(args.only)
 
     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("─────────────────────────────────────────────")
+    for drive in selected:
+        host = drive.host(use_ip=args.use_ip)
+        counts[mount_drive(drive.name, host, quiet=args.quiet)] += 1
+
+    footer_rule()
     success(f"✅ Mounted:  {counts['mounted']}")
     info(f"⏭️  Skipped:  {counts['skipped']} (already mounted)")
     if counts["failed"]: