Add Windows shell integration and tray mount manager

Author: tbdye

README.md

@@ -56,6 +56,7 @@ source .venv/bin/activate   # On Windows: .venv\Scripts\activate
 
 pip install -e './amitools[vamos]'   # Install amitools from submodule (includes machine68k)
 pip install -e .                     # Install AmiFUSE
+pip install -e '.[windows]'         # Windows only: adds pystray + Pillow for tray/shell integration
 ```
 
 ### macOS-specific
@@ -132,7 +133,10 @@ amifuse uses subcommands for different operations:
 ```bash
 amifuse inspect <image>                    # Inspect RDB partitions
 amifuse mount <image>                      # Mount a filesystem
+amifuse unmount <mountpoint>               # Unmount a filesystem
 amifuse doctor                             # Check dependencies and configuration
+amifuse register                           # Add Windows Explorer context menu entries
+amifuse unregister                         # Remove Windows Explorer context menu entries
 ```
 
 ### Inspecting Disk Images
@@ -182,8 +186,10 @@ Mount lifecycle:
 - `--interactive` / `--foreground` keeps AmiFUSE attached to the terminal.
   Use this for debugging or when you want `Ctrl+C` to unmount from the same
   shell.
-- Windows defaults to interactive mode because there is no standalone
-  unmount command there yet.
+- Windows defaults to daemon mode. You can mount via the Explorer context
+  menu (`amifuse register`), unmount from the system tray icon, or use
+  `amifuse unmount <mountpoint>` from the CLI. Note: the WinFSP "Eject"
+  action does not perform a clean unmount — use the tray or CLI instead.
 - `--profile` implies interactive mode.
 
 ### Diagnosing Issues
@@ -311,13 +317,37 @@ The `--icons` flag enables conversion of Amiga `.info` icon files to native Find
 
 *** This feature is experimental and macOS-only. ***
 
+## Windows Shell Integration
+
+On Windows, AmiFUSE can integrate with Explorer for a right-click mount
+experience and a system tray mount manager.
+
+### Context menu registration
+
+```bash
+amifuse register      # Add "Mount with AmiFUSE" to .hdf/.adf context menus
+amifuse unregister    # Remove the context menu entries
+```
+
+Registration writes to `HKCU` (current user only) — no administrator privileges
+are required.
+
+### Tray mount manager
+
+When a filesystem is mounted in daemon mode on Windows, the `amifuse-tray`
+helper appears in the system tray. From the tray icon you can see active mounts
+and unmount them cleanly.
+
+The tray requires optional dependencies: install them with
+`pip install amifuse[windows]` (provides pystray and Pillow).
+
 ## Notes
 
 - The filesystem is mounted **read-only** by default; use `--write` for experimental read-write support
 - macOS and Linux default to daemon mode; use `--interactive` if you want
   Ctrl+C to unmount from the same terminal
 - Use `amifuse unmount <mountpoint>` to tear down daemon mounts
-- Windows defaults to interactive mode until it grows a standalone unmount
-  path
+- Windows defaults to daemon mode; unmount via the system tray icon or
+  `amifuse unmount <mountpoint>`
 - macOS Finder/Spotlight indexing is automatically disabled to improve performance
 - First directory traversal may be slow as the handler processes each path; subsequent accesses are cached

amifuse/fuse_fs.py

@@ -16,13 +16,11 @@
 import sys
 import time
 
-# signal.SIGKILL is not defined on Windows; fall back to SIGTERM so that
-# _kill_mount_owner_processes() can still compile and will use the strongest
-# signal available.
-_SIGKILL = getattr(signal, "SIGKILL", signal.SIGTERM)
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple
 
+from .platform import _kill_mount_owner_processes
+
 try:
     from fuse import FUSE, FuseOSError, LoggingMixIn, Operations  # type: ignore
 except ImportError:
@@ -1583,8 +1581,9 @@ def _track_op(self, op: str, path: str, cached: bool = False):
 
     def _root_stat(self):
         now = int(time.time())
+        perm = 0o777 if self.bridge._write_enabled else 0o755
         return {
-            "st_mode": (0o755 | 0o040000),  # drwxr-xr-x
+            "st_mode": (perm | 0o040000),
             "st_nlink": 2,
             "st_size": 0,
             "st_ctime": now,
@@ -2501,11 +2500,6 @@ def mount_fuse(
 
     if foreground is None:
         foreground = plat.mount_runs_in_foreground_by_default()
-    if not foreground and not plat.get_unmount_command(mountpoint):
-        raise SystemExit(
-            "Daemon mode is not supported on this platform yet because there is "
-            "no standalone unmount command. Use --interactive instead."
-        )
 
     # Print startup banner
     print(__banner__)
@@ -2568,6 +2562,12 @@ def mount_fuse(
         "fsname": f"amifuse:{volname}",
         "default_permissions": True,  # Let kernel handle permission checks
     }
+    # WinFSP maps FUSE uid=0/gid=0 to Windows SID S-1-5-0 (Nobody), blocking
+    # write access for the current user.  uid/gid=-1 tells WinFSP to use the
+    # mounting user's SID instead.
+    if sys.platform.startswith("win"):
+        fuse_kwargs["uid"] = -1
+        fuse_kwargs["gid"] = -1
     # subtype is a Linux-only FUSE option; WinFSP and macFUSE don't support it
     if sys.platform.startswith("linux"):
         fuse_kwargs["subtype"] = "amifuse"
@@ -3802,12 +3802,13 @@ def cmd_unmount(args):
         raise SystemExit(f"Mountpoint {mountpoint} is not currently mounted.")
 
     cmd = plat.get_unmount_command(mountpoint)
+    _no_window = {"creationflags": 0x08000000} if sys.platform.startswith("win") else {}
     if cmd:
-        result = subprocess.run(cmd, check=False)
+        result = subprocess.run(cmd, check=False, **_no_window)
         if result.returncode != 0:
             killed_pids = _kill_mount_owner_processes(mountpoint)
             if killed_pids:
-                result = subprocess.run(cmd, check=False)
+                result = subprocess.run(cmd, check=False, **_no_window)
         if result.returncode != 0:
             raise SystemExit(
                 f"Unmount failed with exit code {result.returncode}: "
@@ -3891,84 +3892,16 @@ def cmd_doctor(args):
     _cmd_doctor(args)
 
 
-def _kill_mount_owner_processes(mountpoint: Path) -> List[int]:
-    pids = _find_mount_owner_pids(mountpoint)
-    if not pids:
-        return []
-
-    remaining = []
-    for pid in pids:
-        try:
-            os.kill(pid, signal.SIGTERM)
-            remaining.append(pid)
-        except (ProcessLookupError, OSError):
-            continue
-
-    deadline = time.time() + 1.0
-    while remaining and time.time() < deadline:
-        still_alive = []
-        for pid in remaining:
-            if _pid_exists(pid):
-                still_alive.append(pid)
-        if not still_alive:
-            return pids
-        remaining = still_alive
-        time.sleep(0.05)
-
-    for pid in remaining:
-        try:
-            os.kill(pid, _SIGKILL)
-        except (ProcessLookupError, OSError):
-            continue
-
-    return pids
-
-
-def _find_mount_owner_pids(mountpoint: Path) -> List[int]:
-    """Find PIDs of amifuse processes that own the given mountpoint.
-
-    Uses platform.find_amifuse_mounts() for process discovery, then
-    filters to those matching the given mountpoint.
-    """
-    from . import platform as plat
-
-    raw_mountpoint = str(mountpoint)
-    abs_mountpoint = str(mountpoint.resolve(strict=False))
-
-    try:
-        all_mounts = plat.find_amifuse_mounts()
-    except OSError:
-        return []
+def cmd_register(args):
+    """Handle the 'register' subcommand."""
+    from .windows_shell import register
+    register()
 
-    pids = []
-    for mount in all_mounts:
-        mp = mount.get("mountpoint")
-        if mp is None:
-            continue
-        if mp == raw_mountpoint or mp == abs_mountpoint:
-            pids.append(mount["pid"])
-            continue
-        try:
-            resolved = str(Path(mp).expanduser().resolve(strict=False))
-        except OSError:
-            continue
-        if resolved == abs_mountpoint:
-            pids.append(mount["pid"])
 
-    return pids
-
-
-def _pid_exists(pid: int) -> bool:
-    try:
-        os.kill(pid, 0)
-    except ProcessLookupError:
-        return False
-    except PermissionError:
-        return True
-    except OSError:
-        # Windows raises a generic OSError for invalid/dead PIDs
-        return False
-    return True
+def cmd_unregister(args):
+    """Handle the 'unregister' subcommand."""
+    from .windows_shell import unregister
+    unregister()
 
 
 def _validate_driver_path(driver: Optional[Path]) -> None:
@@ -4017,6 +3950,9 @@ def main(argv=None):
     --json                    Output results as JSON.
     --fix                     Auto-fix what can be fixed.
 
+  register                  Add Windows Explorer context menu entries.
+  unregister                Remove Windows Explorer context menu entries.
+
   format <image> <partition> [volname]
                               Format an Amiga partition.
     --driver PATH             Filesystem binary (default: extract from RDB).
@@ -4176,6 +4112,17 @@ def main(argv=None):
     )
     doctor_parser.set_defaults(func=cmd_doctor)
 
+    # register / unregister subcommands (Windows shell integration)
+    register_parser = subparsers.add_parser(
+        "register", help="Register AmiFUSE file associations (Windows)."
+    )
+    register_parser.set_defaults(func=cmd_register)
+
+    unregister_parser = subparsers.add_parser(
+        "unregister", help="Remove AmiFUSE file associations (Windows)."
+    )
+    unregister_parser.set_defaults(func=cmd_unregister)
+
     # format subcommand
     format_parser = subparsers.add_parser(
         "format", help="Format an Amiga partition."

amifuse/launcher.py

@@ -0,0 +1,136 @@
+"""Console-free launcher for AmiFUSE context menu actions.
+
+This launcher is invoked by Explorer shell verbs. It MUST exit as fast as
+possible -- any delay blocks the Explorer UI thread. All file I/O uses
+open/write/close immediately; process exit uses os._exit() to skip Python
+shutdown overhead.
+"""
+
+import argparse
+import ctypes
+import os
+import subprocess
+import sys
+from datetime import datetime
+from pathlib import Path
+
+DETACHED_PROCESS = 0x00000008
+CREATE_NEW_PROCESS_GROUP = 0x00000200
+CREATE_NO_WINDOW = 0x08000000
+CREATE_NEW_CONSOLE = 0x00000010
+CREATE_BREAKAWAY_FROM_JOB = 0x01000000
+
+_DETACHED_FLAGS = DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP | CREATE_NO_WINDOW
+
+_LOG_DIR = Path(os.environ.get("APPDATA", "")) / "AmiFUSE"
+
+
+def _log(msg: str) -> None:
+    """Append a single log line, opening and closing the file immediately."""
+    try:
+        _LOG_DIR.mkdir(parents=True, exist_ok=True)
+        ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S,%f")[:-3]
+        with open(str(_LOG_DIR / "launcher.log"), "a") as f:
+            f.write(f"{ts} INFO {msg}\n")
+    except OSError:
+        pass
+
+
+def _spawn_detached(cmd: list[str], **kwargs) -> None:
+    """Spawn a fully detached process. Tries CREATE_BREAKAWAY_FROM_JOB first
+    to escape Explorer's job object; falls back without it if the job
+    doesn't allow breakaway."""
+    flags = _DETACHED_FLAGS | CREATE_BREAKAWAY_FROM_JOB
+    try:
+        subprocess.Popen(cmd, creationflags=flags, **kwargs)
+    except OSError:
+        # Job doesn't allow breakaway -- retry without it
+        subprocess.Popen(cmd, creationflags=_DETACHED_FLAGS, **kwargs)
+
+
+def main(argv=None) -> None:
+    parser = argparse.ArgumentParser(description="AmiFUSE launcher")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    mount_p = sub.add_parser("mount", help="Mount a disk image")
+    mount_p.add_argument("image")
+    mount_p.add_argument("--write", action="store_true")
+
+    inspect_p = sub.add_parser("inspect", help="Open inspect in a new console")
+    inspect_p.add_argument("image")
+
+    args = parser.parse_args(argv)
+
+    if args.command == "mount":
+        _do_mount(args)
+    elif args.command == "inspect":
+        _do_inspect(args)
+
+    # Force-exit immediately. Python's normal shutdown (atexit handlers,
+    # logging.shutdown, GC, module cleanup) is unnecessary for a launcher
+    # and can delay process exit enough to hang Explorer.
+    os._exit(0)
+
+
+def _do_mount(args) -> None:
+    python_dir = Path(sys.executable).parent
+    python_exe = str(python_dir / "pythonw.exe")
+    if not os.path.isfile(python_exe):
+        python_exe = sys.executable
+
+    cmd = [python_exe, "-m", "amifuse", "mount"]
+    if args.write:
+        cmd.append("--write")
+    cmd.append("--daemon")
+    cmd.append(args.image)
+
+    _log(f"Launching mount: {cmd}")
+    try:
+        _spawn_detached(
+            cmd,
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            close_fds=True,
+        )
+    except Exception as exc:
+        _log(f"Failed to launch mount subprocess: {exc}")
+        return
+
+    _ensure_tray_running()
+
+
+def _do_inspect(args) -> None:
+    cmd = ["cmd", "/k", sys.executable, "-m", "amifuse", "inspect", args.image]
+    subprocess.Popen(cmd, creationflags=CREATE_NEW_CONSOLE)
+
+
+def _ensure_tray_running() -> None:
+    handle = ctypes.windll.kernel32.OpenMutexW(
+        0x00100000, False, "AmiFUSE_Tray_Mutex"
+    )
+    if handle != 0:
+        ctypes.windll.kernel32.CloseHandle(handle)
+        return
+
+    tray_exe = str(Path(sys.executable).parent / "amifuse-tray.exe")
+    if os.path.isfile(tray_exe):
+        cmd = [tray_exe]
+    else:
+        cmd = [sys.executable, "-m", "amifuse.tray"]
+
+    _log(f"Starting tray: {cmd}")
+    try:
+        _spawn_detached(
+            cmd,
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            close_fds=True,
+        )
+    except Exception as exc:
+        _log(f"Failed to start tray: {exc}")
+
+
+if __name__ == "__main__":
+    main()