Safer rm with send2trash

rm is permanent: a typo or bad glob can wipe files with no recovery path. A safer workflow keeps the familiar rm interface but routes deletions through the OS trash first — and, using send2trash, works identically on macOS and Linux (and Windows).

§1. Backend: send2trash

send2trash moves files to the operating system’s native trash — ~/.Trash on macOS, ~/.local/share/Trash on Linux, the Recycle Bin on Windows. Because it uses the native trash, terminal deletions also show up in Finder or the desktop file manager, where they can be restored.

python -m pip install --user Send2Trash
# or: pipx install send2trash

§2. Frontend: rmtrash

rmtrash wraps send2trash and accepts the usual rm flags. One deliberate difference: files and folders are trashed identically — a directory goes to the trash without -r. From rm’s perspective a file and a folder are the same, so -r is pure noise; the wrapper drops that requirement while still accepting -r/-R for compatibility. It also refuses /, ., .. and honors rm’s prompting (-i always, -I once for >3 items or any directory).

Save the script (full source in the Appendix) as ~/bin/rmtrash and make it executable:

chmod +x ~/bin/rmtrash

§3. Wire up the alias

alias rm=~/bin/rmtrash

rm foo.txt and rm some-dir both go to the trash.

§4. Inspect and restore

Use the OS tools already available: Finder’s Trash → “Put Back”, or ls ~/.Trash on macOS / ls ~/.local/share/Trash/files on Linux. No separate trash commands to learn.

§5. Cleanup

The OS already manages and empties the trash — empty it manually from the file manager when convenient. No cron or launchd job needed.

The result is a safer, cross-platform rm with a bounded, OS-managed trash.

§Appendix: the rmtrash script

#!/usr/bin/env python3
"""rm-ish command that sends files and directories to the OS trash."""

from __future__ import annotations

import os
import stat
import sys
from dataclasses import dataclass
from pathlib import Path

try:
    from send2trash import send2trash
except ImportError:  # pragma: no cover - exercised only on missing dependency
    print(
        "rmtrash: Python package 'Send2Trash' is not installed.\n"
        "Install it with: python -m pip install --user Send2Trash",
        file=sys.stderr,
    )
    sys.exit(4)


APP_NAME = Path(sys.argv[0]).name
VERSION = "2.0-send2trash"


@dataclass
class Options:
    force: bool = False
    interactive: str = "default"
    prompt_once: bool = False
    verbose: bool = False
    paths: list[str] | None = None


def usage(stream=sys.stdout) -> None:
    print(f"Usage: {APP_NAME} [OPTION]... FILE...", file=stream)


def help_text() -> None:
    usage()
    print(
        """
Send files and directories to the operating system trash.

This intentionally accepts directories without requiring -r, matching the
safe-trash behavior preferred for an rm alias.

Options:
  -f, --force               ignore nonexistent files, never prompt
  -i                        prompt before every trash operation
  -I                        prompt once before trashing many items or directories
      --interactive[=WHEN]  prompt according to WHEN: never, once, or always
  -r, -R, --recursive       accepted for rm compatibility
  -d, --dir                 accepted for rm compatibility
      --one-file-system     accepted for rm compatibility
      --preserve-root       refuse to trash / (default)
      --no-preserve-root    accepted, but / is still refused
  -v, --verbose             explain what is being done
      --help                display this help and exit
      --version             output version information and exit
""".strip()
    )


def parse_interactive(value: str | None) -> str:
    if value in (None, "", "always", "yes"):
        return "always"
    if value in ("never", "no", "none"):
        return "never"
    if value == "once":
        return "once"
    print(f"{APP_NAME}: invalid argument '{value}' for '--interactive'", file=sys.stderr)
    print("Valid arguments are: never, no, none, once, always, yes", file=sys.stderr)
    sys.exit(2)


def parse_args(argv: list[str]) -> Options:
    opts = Options(paths=[])
    end_of_options = False

    for arg in argv:
        if end_of_options:
            opts.paths.append(arg)
            continue

        if arg == "--":
            end_of_options = True
        elif arg == "--help":
            help_text()
            sys.exit(0)
        elif arg == "--version":
            print(f"{APP_NAME} {VERSION}")
            sys.exit(0)
        elif arg == "--force":
            opts.force = True
            opts.interactive = "never"
        elif arg.startswith("--interactive="):
            opts.force = False
            opts.interactive = parse_interactive(arg.split("=", 1)[1])
        elif arg == "--interactive":
            opts.force = False
            opts.interactive = "always"
        elif arg in ("--recursive", "--dir", "--one-file-system", "--preserve-root", "--no-preserve-root"):
            pass
        elif arg == "--verbose":
            opts.verbose = True
        elif arg.startswith("--"):
            print(f"{APP_NAME}: unrecognized option '{arg}'", file=sys.stderr)
            usage(sys.stderr)
            sys.exit(2)
        elif arg.startswith("-") and arg != "-":
            for flag in arg[1:]:
                if flag == "f":
                    opts.force = True
                    opts.interactive = "never"
                elif flag == "i":
                    opts.force = False
                    opts.interactive = "always"
                elif flag == "I":
                    opts.force = False
                    opts.interactive = "once"
                elif flag in ("r", "R", "d"):
                    pass
                elif flag == "v":
                    opts.verbose = True
                else:
                    print(f"{APP_NAME}: invalid option -- '{flag}'", file=sys.stderr)
                    usage(sys.stderr)
                    sys.exit(2)
        else:
            opts.paths.append(arg)

    if opts.interactive == "once":
        opts.prompt_once = True
        opts.interactive = "default"

    return opts


def strip_trailing_slashes(path: str) -> str:
    if path == "/":
        return path
    stripped = path.rstrip("/")
    return stripped or path


def protected_path(raw: str) -> str | None:
    path = strip_trailing_slashes(raw)
    if path == "/":
        return "cannot remove root directory '/'"
    if Path(path).name in (".", ".."):
        return f"refusing to remove '.' or '..' directory: skipping '{raw}'"
    return None


def exists_or_link(path: str) -> bool:
    return os.path.exists(path) or os.path.islink(path)


def is_directory(path: str) -> bool:
    try:
        mode = os.lstat(path).st_mode
    except OSError:
        return False
    if stat.S_ISLNK(mode):
        return False
    return stat.S_ISDIR(mode)


def prompt(question: str) -> bool:
    if not sys.stdin.isatty():
        print(f"{APP_NAME}: refusing interactive prompt without a terminal", file=sys.stderr)
        return False
    answer = input(f"{question} ")
    return answer.lower() in ("y", "yes")


def should_prompt_once(paths: list[str]) -> bool:
    if len(paths) > 3:
        return True
    return any(exists_or_link(path) and is_directory(path) for path in paths)


def main(argv: list[str]) -> int:
    opts = parse_args(argv)
    paths = opts.paths or []

    if not paths:
        print(f"{APP_NAME}: too few arguments", file=sys.stderr)
        usage(sys.stderr)
        return 2

    exit_code = 0
    candidates: list[tuple[str, str]] = []

    for raw in paths:
        reason = protected_path(raw)
        if reason is not None:
            print(f"{APP_NAME}: {reason}", file=sys.stderr)
            exit_code = 1
            continue

        path = strip_trailing_slashes(raw)
        if not exists_or_link(path):
            if not opts.force:
                print(f"{APP_NAME}: cannot remove '{raw}': No such file or directory", file=sys.stderr)
                exit_code = 1
            continue

        candidates.append((raw, path))

    if opts.prompt_once and candidates and should_prompt_once([path for _, path in candidates]):
        if not prompt(f"{APP_NAME}: trash {len(candidates)} item(s)?"):
            return exit_code

    for raw, path in candidates:
        if opts.interactive == "always" and not prompt(f"{APP_NAME}: trash '{raw}'?"):
            continue

        try:
            send2trash(path)
        except Exception as exc:  # noqa: BLE001 - command-line tool reports all trash failures
            print(f"{APP_NAME}: cannot trash '{raw}': {exc}", file=sys.stderr)
            exit_code = 1
            continue

        if opts.verbose:
            print(f"{APP_NAME}: trashed '{raw}'")

    return exit_code


if __name__ == "__main__":
    sys.exit(main(sys.argv[1:]))