mac-android-file-transfer 0.1.0__tar.gz

mac_android_file_transfer-0.1.0/.gitignore

@@ -0,0 +1,6 @@
+.venv/
+.env
+.pytest_cache/
+.ruff_cache/
+__pycache__/
+*.py[cod]

mac_android_file_transfer-0.1.0/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: mac-android-file-transfer
+Version: 0.1.0
+Summary: macOS CLI wrapper around go-mtpfs for Android file transfer
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# mac-android-file-transfer
+
+`maft` is a macOS CLI wrapper around
+[`github.com/ganeshrvel/go-mtpfs`](https://github.com/ganeshrvel/go-mtpfs).
+It mounts Android MTP storage to a local folder, then provides explicit `cp`,
+`mv`, and `rm` commands over that mounted filesystem.
+
+## Requirements
+
+- macOS
+- macFUSE
+- `go-mtpfs` available in `PATH`
+- `diskutil` or `/sbin/umount` for unmounting
+
+Run:
+
+```sh
+maft doctor
+```
+
+## Usage
+
+```sh
+maft mount ~/Android
+maft cp --mount ~/Android ~/Downloads/photo.jpg DCIM/photo.jpg
+maft cp --mount ~/Android -r DCIM ~/Desktop/DCIM
+maft mv --mount ~/Android DCIM/photo.jpg Pictures/photo.jpg
+maft rm --mount ~/Android Pictures/photo.jpg
+maft rm --mount ~/Android -r Pictures/old-folder
+maft unmount ~/Android
+```
+
+For file commands, absolute paths and `~/...` paths are treated as host paths.
+Other paths are treated as Android paths relative to the mount folder.

mac_android_file_transfer-0.1.0/README.md

@@ -0,0 +1,34 @@
+# mac-android-file-transfer
+
+`maft` is a macOS CLI wrapper around
+[`github.com/ganeshrvel/go-mtpfs`](https://github.com/ganeshrvel/go-mtpfs).
+It mounts Android MTP storage to a local folder, then provides explicit `cp`,
+`mv`, and `rm` commands over that mounted filesystem.
+
+## Requirements
+
+- macOS
+- macFUSE
+- `go-mtpfs` available in `PATH`
+- `diskutil` or `/sbin/umount` for unmounting
+
+Run:
+
+```sh
+maft doctor
+```
+
+## Usage
+
+```sh
+maft mount ~/Android
+maft cp --mount ~/Android ~/Downloads/photo.jpg DCIM/photo.jpg
+maft cp --mount ~/Android -r DCIM ~/Desktop/DCIM
+maft mv --mount ~/Android DCIM/photo.jpg Pictures/photo.jpg
+maft rm --mount ~/Android Pictures/photo.jpg
+maft rm --mount ~/Android -r Pictures/old-folder
+maft unmount ~/Android
+```
+
+For file commands, absolute paths and `~/...` paths are treated as host paths.
+Other paths are treated as Android paths relative to the mount folder.

mac_android_file_transfer-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "mac-android-file-transfer"
+version = "0.1.0"
+description = "macOS CLI wrapper around go-mtpfs for Android file transfer"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = []
+
+[project.scripts]
+maft = "maft.cli:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/maft"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B", "UP", "SIM", "RUF"]
+
+[tool.basedpyright]
+include = ["src", "tests"]
+pythonVersion = "3.12"
+typeCheckingMode = "strict"

mac_android_file_transfer-0.1.0/src/maft/__init__.py

@@ -0,0 +1,5 @@
+"""macOS Android file transfer CLI."""
+
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

mac_android_file_transfer-0.1.0/src/maft/cli.py

@@ -0,0 +1,385 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+import subprocess
+import sys
+import time
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import cast
+
+from maft import __version__
+
+APP_NAME = "maft"
+DEFAULT_STATE_DIR = Path.home() / "Library" / "Application Support" / APP_NAME
+DEFAULT_MACFUSE_PATHS = (
+    Path("/Library/Filesystems/macfuse.fs"),
+    Path("/Library/Filesystems/osxfuse.fs"),
+)
+
+
+@dataclass(frozen=True)
+class MountRecord:
+    mountpoint: str
+    pid: int
+    command: list[str]
+    created_at: float
+
+
+class CliError(Exception):
+    pass
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    try:
+        return args.func(args)
+    except CliError as exc:
+        print(f"maft: {exc}", file=sys.stderr)
+        return 1
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="maft",
+        description="Mount and manage Android MTP files on macOS via go-mtpfs.",
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    doctor = subparsers.add_parser("doctor", help="check local dependencies")
+    doctor.set_defaults(func=cmd_doctor)
+
+    mount = subparsers.add_parser("mount", help="mount an Android device")
+    mount.add_argument("mountpoint")
+    mount.add_argument("--dev", help="go-mtpfs device selector")
+    mount.add_argument("--storage", help="go-mtpfs storage selector")
+    mount.add_argument("--android", dest="android", action="store_true", default=True)
+    mount.add_argument("--no-android", dest="android", action="store_false")
+    mount.add_argument("--allow-other", action="store_true")
+    mount.add_argument("--debug", action="store_true")
+    mount.add_argument("--usb-timeout", type=int, help="go-mtpfs USB timeout")
+    mount.set_defaults(func=cmd_mount)
+
+    unmount = subparsers.add_parser("unmount", help="unmount an Android mount folder")
+    unmount.add_argument("mountpoint")
+    unmount.set_defaults(func=cmd_unmount)
+
+    cp = subparsers.add_parser("cp", help="copy files to, from, or within a mounted device")
+    add_mount_arg(cp)
+    cp.add_argument("-r", "--recursive", action="store_true", help="copy directories recursively")
+    cp.add_argument("src")
+    cp.add_argument("dst")
+    cp.set_defaults(func=cmd_cp)
+
+    mv = subparsers.add_parser("mv", help="move files to, from, or within a mounted device")
+    add_mount_arg(mv)
+    mv.add_argument("src")
+    mv.add_argument("dst")
+    mv.set_defaults(func=cmd_mv)
+
+    rm = subparsers.add_parser("rm", help="remove files from a mounted device")
+    add_mount_arg(rm)
+    rm.add_argument("-r", "--recursive", action="store_true", help="remove directories recursively")
+    rm.add_argument("paths", nargs="+")
+    rm.set_defaults(func=cmd_rm)
+
+    return parser
+
+
+def add_mount_arg(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "--mount",
+        required=True,
+        dest="mountpoint",
+        help="mounted Android folder",
+    )
+
+
+def cmd_doctor(_args: argparse.Namespace) -> int:
+    checks = [
+        ("go-mtpfs", shutil.which("go-mtpfs") is not None, install_go_mtpfs_help()),
+        ("diskutil", shutil.which("diskutil") is not None, "Provided by macOS."),
+        ("/sbin/umount", Path("/sbin/umount").exists(), "Provided by macOS."),
+        ("macFUSE", macfuse_available(), "Install from https://macfuse.github.io/."),
+    ]
+
+    failed = False
+    for name, ok, help_text in checks:
+        status = "ok" if ok else "missing"
+        print(f"{name}: {status}")
+        if not ok:
+            failed = True
+            print(f"  {help_text}")
+    return 1 if failed else 0
+
+
+def cmd_mount(args: argparse.Namespace) -> int:
+    go_mtpfs = shutil.which("go-mtpfs")
+    if go_mtpfs is None:
+        raise CliError(f"go-mtpfs not found in PATH. {install_go_mtpfs_help()}")
+    if not macfuse_available():
+        raise CliError("macFUSE was not detected. Install it from https://macfuse.github.io/.")
+
+    mountpoint = expand_path(args.mountpoint)
+    if mountpoint.exists() and not mountpoint.is_dir():
+        raise CliError(f"mountpoint exists and is not a directory: {mountpoint}")
+    mountpoint.mkdir(parents=True, exist_ok=True)
+
+    command = [go_mtpfs]
+    if args.dev:
+        command.extend(["-dev", args.dev])
+    if args.storage:
+        command.extend(["-storage", args.storage])
+    if not args.android:
+        command.append("-android=false")
+    if args.allow_other:
+        command.append("-allow-other")
+    if args.debug:
+        command.append("-debug")
+    if args.usb_timeout is not None:
+        command.extend(["-usb-timeout", str(args.usb_timeout)])
+    command.append(str(mountpoint))
+
+    stdout = None if args.debug else subprocess.DEVNULL
+    stderr = None if args.debug else subprocess.DEVNULL
+    process = subprocess.Popen(command, stdout=stdout, stderr=stderr, start_new_session=True)
+    write_mount_record(
+        MountRecord(
+            mountpoint=str(mountpoint),
+            pid=process.pid,
+            command=command,
+            created_at=time.time(),
+        )
+    )
+    print(f"mounted {mountpoint} with go-mtpfs pid {process.pid}")
+    return 0
+
+
+def cmd_unmount(args: argparse.Namespace) -> int:
+    mountpoint = require_dir(expand_path(args.mountpoint), "mountpoint")
+    errors: list[str] = []
+    diskutil = shutil.which("diskutil")
+    if diskutil is not None:
+        result = subprocess.run(
+            [diskutil, "unmount", str(mountpoint)],
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode == 0:
+            remove_mount_record(mountpoint)
+            print(f"unmounted {mountpoint}")
+            return 0
+        errors.append(result.stderr.strip() or result.stdout.strip() or "diskutil unmount failed")
+
+    umount = shutil.which("umount") or "/sbin/umount"
+    result = subprocess.run(
+        [umount, str(mountpoint)],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode == 0:
+        remove_mount_record(mountpoint)
+        print(f"unmounted {mountpoint}")
+        return 0
+    errors.append(result.stderr.strip() or result.stdout.strip() or "umount failed")
+
+    joined = "; ".join(error for error in errors if error)
+    raise CliError(f"could not unmount {mountpoint}: {joined}")
+
+
+def cmd_cp(args: argparse.Namespace) -> int:
+    mountpoint = require_mountpoint(args.mountpoint)
+    src = resolve_operation_path(mountpoint, args.src)
+    dst = resolve_operation_path(mountpoint, args.dst)
+
+    if src.path.is_dir():
+        if not args.recursive:
+            raise CliError(f"{src.original} is a directory; pass --recursive")
+        copy_directory(src.path, destination_for_copy(dst.path, src.path.name))
+    else:
+        copy_file(src.path, destination_for_copy(dst.path, src.path.name))
+    return 0
+
+
+def cmd_mv(args: argparse.Namespace) -> int:
+    mountpoint = require_mountpoint(args.mountpoint)
+    src = resolve_operation_path(mountpoint, args.src)
+    dst = resolve_operation_path(mountpoint, args.dst)
+    target = destination_for_copy(dst.path, src.path.name)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    shutil.move(str(src.path), str(target))
+    return 0
+
+
+def cmd_rm(args: argparse.Namespace) -> int:
+    mountpoint = require_mountpoint(args.mountpoint)
+    for raw_path in args.paths:
+        if is_host_path(raw_path):
+            raise CliError(f"rm only accepts Android-relative paths, got host path: {raw_path}")
+        target = resolve_android_path(mountpoint, raw_path)
+        if target.is_dir():
+            if not args.recursive:
+                raise CliError(f"{raw_path} is a directory; pass --recursive")
+            shutil.rmtree(target)
+        elif target.exists():
+            target.unlink()
+        else:
+            raise CliError(f"path does not exist: {raw_path}")
+    return 0
+
+
+@dataclass(frozen=True)
+class OperationPath:
+    original: str
+    path: Path
+    is_host: bool
+
+
+def resolve_operation_path(mountpoint: Path, value: str) -> OperationPath:
+    if is_host_path(value):
+        return OperationPath(value, expand_path(value), True)
+    return OperationPath(value, resolve_android_path(mountpoint, value), False)
+
+
+def resolve_android_path(mountpoint: Path, value: str) -> Path:
+    if value in {"", "."}:
+        return mountpoint
+    candidate = (mountpoint / value).resolve(strict=False)
+    try:
+        candidate.relative_to(mountpoint)
+    except ValueError as exc:
+        raise CliError(f"Android path escapes mountpoint: {value}") from exc
+    return candidate
+
+
+def is_host_path(value: str) -> bool:
+    return value.startswith("/") or value.startswith("~/") or value == "~"
+
+
+def destination_for_copy(destination: Path, source_name: str) -> Path:
+    if destination.exists() and destination.is_dir():
+        return destination / source_name
+    if str(destination).endswith(os.sep):
+        destination.mkdir(parents=True, exist_ok=True)
+        return destination / source_name
+    return destination
+
+
+def copy_file(src: Path, dst: Path) -> None:
+    if not src.is_file():
+        raise CliError(f"source file does not exist: {src}")
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(src, dst)
+
+
+def copy_directory(src: Path, dst: Path) -> None:
+    if not src.is_dir():
+        raise CliError(f"source directory does not exist: {src}")
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copytree(src, dst, dirs_exist_ok=True)
+
+
+def require_mountpoint(value: str) -> Path:
+    mountpoint = require_dir(expand_path(value), "mountpoint")
+    return mountpoint.resolve(strict=True)
+
+
+def require_dir(path: Path, label: str) -> Path:
+    if not path.exists():
+        raise CliError(f"{label} does not exist: {path}")
+    if not path.is_dir():
+        raise CliError(f"{label} is not a directory: {path}")
+    return path
+
+
+def expand_path(value: str) -> Path:
+    return Path(value).expanduser().resolve(strict=False)
+
+
+def state_dir() -> Path:
+    override = os.environ.get("MAFT_STATE_DIR")
+    return Path(override).expanduser() if override else DEFAULT_STATE_DIR
+
+
+def state_file() -> Path:
+    return state_dir() / "mounts.json"
+
+
+def load_mount_records() -> dict[str, MountRecord]:
+    path = state_file()
+    if not path.exists():
+        return {}
+    data: object = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(data, dict):
+        raise CliError(f"invalid state file: {path}")
+    raw_records = cast("dict[object, object]", data)
+    records: dict[str, MountRecord] = {}
+    for mountpoint, record in raw_records.items():
+        if not isinstance(mountpoint, str) or not isinstance(record, dict):
+            continue
+        raw_record = cast("dict[object, object]", record)
+        raw_command = raw_record.get("command")
+        raw_mountpoint = raw_record.get("mountpoint")
+        raw_pid = raw_record.get("pid")
+        raw_created_at = raw_record.get("created_at")
+        if (
+            not isinstance(raw_mountpoint, str)
+            or not isinstance(raw_pid, int)
+            or not isinstance(raw_created_at, int | float)
+            or not isinstance(raw_command, list)
+        ):
+            continue
+        command = cast("list[object]", raw_command)
+        records[mountpoint] = MountRecord(
+            mountpoint=raw_mountpoint,
+            pid=raw_pid,
+            command=[str(part) for part in command],
+            created_at=float(raw_created_at),
+        )
+    return records
+
+
+def save_mount_records(records: dict[str, MountRecord]) -> None:
+    directory = state_dir()
+    directory.mkdir(parents=True, exist_ok=True)
+    state_file().write_text(
+        json.dumps({key: asdict(value) for key, value in records.items()}, indent=2) + "\n",
+        encoding="utf-8",
+    )
+
+
+def write_mount_record(record: MountRecord) -> None:
+    records = load_mount_records()
+    records[record.mountpoint] = record
+    save_mount_records(records)
+
+
+def remove_mount_record(mountpoint: Path) -> None:
+    records = load_mount_records()
+    records.pop(str(mountpoint.resolve(strict=False)), None)
+    save_mount_records(records)
+
+
+def macfuse_available() -> bool:
+    override = os.environ.get("MAFT_MACFUSE_PATHS")
+    paths = [Path(path).expanduser() for path in override.split(os.pathsep)] if override else list(
+        DEFAULT_MACFUSE_PATHS
+    )
+    return any(path.exists() for path in paths)
+
+
+def install_go_mtpfs_help() -> str:
+    return (
+        "Install Go and go-mtpfs, for example: "
+        "brew install go libusb pkg-config && go install github.com/ganeshrvel/go-mtpfs@latest"
+    )
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mac_android_file_transfer-0.1.0/tests/e2e/test_cli.py

@@ -0,0 +1,224 @@
+from __future__ import annotations
+
+import json
+import os
+import stat
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+PYTHONPATH = str(ROOT / "src")
+
+
+def run_maft(
+    tmp_path: Path,
+    *args: str,
+    path: str | None = None,
+) -> subprocess.CompletedProcess[str]:
+    env = os.environ.copy()
+    env["PYTHONPATH"] = PYTHONPATH
+    env["MAFT_STATE_DIR"] = str(tmp_path / "state")
+    env["MAFT_MACFUSE_PATHS"] = str(tmp_path / "macfuse.fs")
+    if path is not None:
+        env["PATH"] = path
+    return subprocess.run(
+        [sys.executable, "-m", "maft.cli", *args],
+        cwd=ROOT,
+        env=env,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+
+
+def make_executable(path: Path, content: str) -> None:
+    path.write_text(content, encoding="utf-8")
+    path.chmod(path.stat().st_mode | stat.S_IXUSR)
+
+
+def test_version_flag_prints_current_version(tmp_path: Path) -> None:
+    result = run_maft(tmp_path, "--version")
+
+    assert result.returncode == 0
+    assert result.stdout == "maft 0.1.0\n"
+
+
+def test_doctor_reports_missing_backend(tmp_path: Path) -> None:
+    result = run_maft(tmp_path, "doctor", path="/usr/bin:/bin")
+
+    assert result.returncode == 1
+    assert "go-mtpfs: missing" in result.stdout
+    assert "macFUSE: missing" in result.stdout
+
+
+def test_mount_invokes_go_mtpfs_and_records_metadata(tmp_path: Path) -> None:
+    bin_dir = tmp_path / "bin"
+    bin_dir.mkdir()
+    log = tmp_path / "go-mtpfs.log"
+    make_executable(
+        bin_dir / "go-mtpfs",
+        f"#!/bin/sh\nprintf '%s\\n' \"$@\" > {log}\nexit 0\n",
+    )
+    (tmp_path / "macfuse.fs").mkdir()
+    mountpoint = tmp_path / "Android"
+
+    result = run_maft(
+        tmp_path,
+        "mount",
+        str(mountpoint),
+        "--dev",
+        "1",
+        "--storage",
+        "2",
+        "--allow-other",
+        "--usb-timeout",
+        "10",
+        path=f"{bin_dir}:/usr/bin:/bin",
+    )
+
+    assert result.returncode == 0, result.stderr
+    assert mountpoint.is_dir()
+    wait_for_path(log)
+    invocation = log.read_text(encoding="utf-8")
+    assert "-dev\n1\n-storage\n2\n-allow-other\n-usb-timeout\n10" in invocation
+    state = json.loads((tmp_path / "state" / "mounts.json").read_text(encoding="utf-8"))
+    assert str(mountpoint.resolve()) in state
+
+
+def test_unmount_uses_available_command_and_cleans_metadata(tmp_path: Path) -> None:
+    bin_dir = tmp_path / "bin"
+    bin_dir.mkdir()
+    log = tmp_path / "umount.log"
+    make_executable(bin_dir / "umount", f"#!/bin/sh\nprintf '%s\\n' \"$@\" > {log}\nexit 0\n")
+    mountpoint = tmp_path / "Android"
+    mountpoint.mkdir()
+    state_dir = tmp_path / "state"
+    state_dir.mkdir()
+    (state_dir / "mounts.json").write_text(
+        json.dumps(
+            {
+                str(mountpoint.resolve()): {
+                    "mountpoint": str(mountpoint.resolve()),
+                    "pid": 123,
+                    "command": ["go-mtpfs", str(mountpoint.resolve())],
+                    "created_at": 1.0,
+                }
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    result = run_maft(tmp_path, "unmount", str(mountpoint), path=f"{bin_dir}:/usr/bin:/bin")
+
+    assert result.returncode == 0, result.stderr
+    assert str(mountpoint) in log.read_text(encoding="utf-8")
+    state = json.loads((state_dir / "mounts.json").read_text(encoding="utf-8"))
+    assert state == {}
+
+
+def test_cp_mv_rm_file_operations_against_mount_folder(tmp_path: Path) -> None:
+    mountpoint = tmp_path / "Android"
+    host = tmp_path / "host"
+    mountpoint.mkdir()
+    host.mkdir()
+    (host / "photo.jpg").write_text("photo", encoding="utf-8")
+
+    copy_to_device = run_maft(
+        tmp_path,
+        "cp",
+        "--mount",
+        str(mountpoint),
+        str(host / "photo.jpg"),
+        "DCIM/photo.jpg",
+    )
+    assert copy_to_device.returncode == 0, copy_to_device.stderr
+    assert (mountpoint / "DCIM" / "photo.jpg").read_text(encoding="utf-8") == "photo"
+
+    move_on_device = run_maft(
+        tmp_path,
+        "mv",
+        "--mount",
+        str(mountpoint),
+        "DCIM/photo.jpg",
+        "Pictures/photo.jpg",
+    )
+    assert move_on_device.returncode == 0, move_on_device.stderr
+    assert not (mountpoint / "DCIM" / "photo.jpg").exists()
+    assert (mountpoint / "Pictures" / "photo.jpg").exists()
+
+    copy_to_host = run_maft(
+        tmp_path,
+        "cp",
+        "--mount",
+        str(mountpoint),
+        "Pictures/photo.jpg",
+        str(host / "copy.jpg"),
+    )
+    assert copy_to_host.returncode == 0, copy_to_host.stderr
+    assert (host / "copy.jpg").read_text(encoding="utf-8") == "photo"
+
+    remove_file = run_maft(tmp_path, "rm", "--mount", str(mountpoint), "Pictures/photo.jpg")
+    assert remove_file.returncode == 0, remove_file.stderr
+    assert not (mountpoint / "Pictures" / "photo.jpg").exists()
+
+
+def test_recursive_operations_and_path_safety(tmp_path: Path) -> None:
+    mountpoint = tmp_path / "Android"
+    host = tmp_path / "host"
+    mountpoint.mkdir()
+    host.mkdir()
+    (host / "album").mkdir()
+    (host / "album" / "a.txt").write_text("a", encoding="utf-8")
+
+    refused_directory_copy = run_maft(
+        tmp_path,
+        "cp",
+        "--mount",
+        str(mountpoint),
+        str(host / "album"),
+        "Albums/album",
+    )
+    assert refused_directory_copy.returncode == 1
+    assert "pass --recursive" in refused_directory_copy.stderr
+
+    copied_directory = run_maft(
+        tmp_path,
+        "cp",
+        "--mount",
+        str(mountpoint),
+        "--recursive",
+        str(host / "album"),
+        "Albums/album",
+    )
+    assert copied_directory.returncode == 0, copied_directory.stderr
+    assert (mountpoint / "Albums" / "album" / "a.txt").exists()
+
+    refused_escape = run_maft(tmp_path, "rm", "--mount", str(mountpoint), "../outside")
+    assert refused_escape.returncode == 1
+    assert "escapes mountpoint" in refused_escape.stderr
+
+    refused_directory_remove = run_maft(tmp_path, "rm", "--mount", str(mountpoint), "Albums")
+    assert refused_directory_remove.returncode == 1
+    assert "pass --recursive" in refused_directory_remove.stderr
+
+    removed_directory = run_maft(
+        tmp_path,
+        "rm",
+        "--mount",
+        str(mountpoint),
+        "--recursive",
+        "Albums",
+    )
+    assert removed_directory.returncode == 0, removed_directory.stderr
+    assert not (mountpoint / "Albums").exists()
+
+
+def wait_for_path(path: Path) -> None:
+    deadline = time.monotonic() + 2
+    while time.monotonic() < deadline:
+        if path.exists():
+            return
+        time.sleep(0.01)
+    raise AssertionError(f"path was not created: {path}")

mac_android_file_transfer-0.1.0/uv.lock

@@ -0,0 +1,8 @@
+version = 1
+revision = 3
+requires-python = ">=3.12"
+
+[[package]]
+name = "mac-android-file-transfer"
+version = "0.1.0"
+source = { editable = "." }