protonfs 0.1.dev43__py3-none-any.whl

protonfs/__init__.py

@@ -0,0 +1,6 @@
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("protonfs")
+except PackageNotFoundError:
+    __version__ = "0.0.0+unknown"

protonfs/batching.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+DEFAULT_BATCH_SIZE = 200
+
+
+def group_by_parent(rel_paths: list[str]) -> dict[str, list[str]]:
+    groups: dict[str, list[str]] = {}
+    for rel in rel_paths:
+        parent = str(Path(rel).parent)
+        groups.setdefault(parent, []).append(rel)
+    return groups
+
+
+def batches(items: list, size: int = DEFAULT_BATCH_SIZE) -> list[list]:
+    return [items[i : i + size] for i in range(0, len(items), size)]

protonfs/cli.py

@@ -0,0 +1,226 @@
+from __future__ import annotations
+
+import functools
+
+import click
+
+from protonfs import __version__
+
+
+def _drive_error_boundary(func):
+    """Wrap a command so DriveError/DriveAuthError become clean ClickExceptions.
+
+    Runtime commands call into the Drive CLI; a mid-run failure there (auth
+    expiry, network, missing path) would otherwise surface as a raw Python
+    traceback instead of a readable message.
+    """
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        from protonfs.drive import DriveAuthError, DriveError
+
+        try:
+            return func(*args, **kwargs)
+        except DriveAuthError as exc:
+            raise click.ClickException(
+                f"{exc}\nRun `proton-drive auth login` to re-authenticate, "
+                "then retry this command."
+            ) from exc
+        except DriveError as exc:
+            raise click.ClickException(str(exc)) from exc
+
+    return wrapper
+
+
+@click.group()
+@click.version_option(__version__, prog_name="protonfs")
+def main() -> None:
+    """Sync a local directory tree with Proton Drive."""
+
+
+@main.command()
+@click.option("--dry-run", is_flag=True, help="Preview the LFS migration without making changes.")
+def setup(dry_run: bool) -> None:
+    """Install/verify the proton-drive CLI, init .protonfs/, migrate off git-lfs if present."""
+    from pathlib import Path
+
+    from protonfs.commands.setup import run_setup
+
+    run_setup(Path.cwd(), dry_run=dry_run)
+
+
+@main.command()
+@click.argument("path", required=False)
+def status(path: str | None) -> None:
+    """Summarize sync state (counts by local-only/remote-only/synced/conflict)."""
+    from protonfs.commands.status import compute_status
+    from protonfs.context import load_context
+    from protonfs.diff import SyncState
+
+    ctx = load_context()
+    counts = compute_status(ctx, path)
+    for state in SyncState:
+        click.echo(f"{state.value}: {counts.get(state.value, 0)}")
+
+
+@main.command()
+@click.argument("path", required=False)
+@click.option("--remote", is_flag=True, help="Force a live Drive listing instead of the index.")
+@click.option("--trash", is_flag=True, help="List /trash instead.")
+@_drive_error_boundary
+def ls(path: str | None, remote: bool, trash: bool) -> None:
+    """List tracked files with their sync state."""
+    from rich.console import Console
+
+    from protonfs.commands.ls import render_ls
+    from protonfs.context import load_context
+
+    ctx = load_context()
+    render_ls(ctx, path, remote, trash, Console())
+
+
+@main.command()
+@click.argument("path", required=False)
+@click.option("--resolve", type=click.Choice(["merge", "keep-both", "replace", "skip"]))
+@click.option("--dry-run", is_flag=True)
+@_drive_error_boundary
+def push(path: str | None, resolve: str | None, dry_run: bool) -> None:
+    """Upload local-only/changed files to Drive."""
+    from protonfs.commands.push import push as push_files
+    from protonfs.context import load_context
+
+    ctx = load_context()
+    result = push_files(ctx, path, resolve, dry_run)
+    click.echo(
+        f"transferred={result.transferred_items} skipped={result.skipped_items} "
+        f"failed={result.failed_items}"
+    )
+    for failure in result.failures:
+        click.echo(f"  FAILED {failure['name']}: {failure['error']}")
+    if result.failed_items:
+        if not resolve:
+            click.echo(
+                "  -> these are remote conflicts; re-run with "
+                "--resolve=merge|keep-both|replace|skip to resolve them."
+            )
+        raise click.exceptions.Exit(1)
+
+
+@main.command()
+@click.argument("path", required=False)
+@click.option("--resolve", type=click.Choice(["merge", "keep-both", "replace", "skip"]))
+@click.option("--dry-run", is_flag=True)
+@click.option(
+    "--refresh",
+    is_flag=True,
+    help="Discover remote files (seed the index) before pulling.",
+)
+@_drive_error_boundary
+def pull(path: str | None, resolve: str | None, dry_run: bool, refresh: bool) -> None:
+    """Download remote-only/changed files from Drive."""
+    from protonfs.commands.pull import pull as pull_files
+    from protonfs.context import load_context
+
+    ctx = load_context()
+    if not refresh and not ctx.index.all():
+        click.echo("index empty; run `protonfs refresh` first (or `pull --refresh`)")
+        return
+    result = pull_files(ctx, path, resolve, dry_run, refresh=refresh)
+    click.echo(
+        f"transferred={result.transferred_items} skipped={result.skipped_items} "
+        f"failed={result.failed_items}"
+    )
+    for failure in result.failures:
+        click.echo(f"  FAILED {failure['name']}: {failure['error']}")
+    if result.failed_items:
+        raise click.exceptions.Exit(1)
+
+
+@main.command()
+@click.argument("path")
+@click.option("-r", "--recursive", is_flag=True)
+@click.option("-f", "--force", is_flag=True, help="Permanently delete (trash, then delete).")
+@click.option("--yes", is_flag=True, help="Skip confirmation prompt.")
+@_drive_error_boundary
+def rm(path: str, recursive: bool, force: bool, yes: bool) -> None:
+    """Remove a file/directory from Drive (trash by default, -f for permanent)."""
+    from protonfs.commands.rm import rm as rm_path
+    from protonfs.context import load_context
+
+    ctx = load_context()
+    rm_path(ctx, path, recursive, force, confirmed=yes)
+
+
+@main.command()
+@click.argument("path")
+@_drive_error_boundary
+def restore(path: str) -> None:
+    """Restore a trashed file/directory on Drive."""
+    from protonfs.commands.restore import restore as restore_path
+    from protonfs.context import load_context
+
+    ctx = load_context()
+    restore_path(ctx, path)
+
+
+@main.command()
+@click.argument("path", required=False)
+@click.option("--prune", is_flag=True, help="Drop index entries for files deleted on the remote.")
+@_drive_error_boundary
+def refresh(path: str | None, prune: bool) -> None:
+    """Discover remote files and seed the local index (metadata-only)."""
+    from protonfs.commands.refresh import refresh as refresh_index
+    from protonfs.context import load_context
+
+    ctx = load_context()
+    result = refresh_index(ctx, path, prune)
+    click.echo(f"Discovered {result.seeded} new remote file(s) (metadata-only).")
+    if result.remote_changed:
+        click.echo(f"  {result.remote_changed} file(s) changed on the remote (remote-changed):")
+        for p in result.changed_paths:
+            click.echo(f"      {p}")
+        click.echo(
+            "    -> `protonfs pull --resolve=replace <path>` to take the remote version, "
+            "or `protonfs push --resolve=replace <path>` to overwrite it with your local copy."
+        )
+    if result.remote_deleted:
+        verb = "pruned" if prune else "found"
+        click.echo(f"  {result.remote_deleted} file(s) deleted on the remote ({verb}):")
+        for p in result.deleted_paths:
+            click.echo(f"      {p}")
+        if not prune:
+            click.echo("    -> `protonfs refresh --prune` to drop them from your local index.")
+    if result.seeded:
+        click.echo(f"Run `protonfs pull` to download the {result.seeded} discovered file(s).")
+
+
+@main.command("install-drive")
+@click.option("--version", default=None, help="proton-drive version to install (default: pinned).")
+def install_drive_cmd(version: str | None) -> None:
+    """Download and verify the official proton-drive CLI binary."""
+    from protonfs.install import InstallError, install_drive
+
+    try:
+        result = install_drive(version=version)
+    except InstallError as exc:
+        raise click.ClickException(str(exc)) from exc
+    click.echo(f"Installed proton-drive to {result.path} (SHA-512 verified).")
+    for warning in result.warnings:
+        click.echo(f"  ! {warning}")
+    click.echo("Next: run `protonfs auth login` to authenticate.")
+
+
+@main.command()
+@click.argument("action", type=click.Choice(["login", "logout", "status"]))
+@_drive_error_boundary
+def auth(action: str) -> None:
+    """Authenticate the proton-drive CLI: login | logout | status (passthrough)."""
+    from protonfs.commands.auth import auth_passthrough
+
+    code = auth_passthrough(action)
+    if code != 0:
+        raise click.exceptions.Exit(code)
+
+
+if __name__ == "__main__":
+    main()

protonfs/commands/auth.py

@@ -0,0 +1,36 @@
+# src/protonfs/commands/auth.py
+"""`protonfs auth {login,logout,status}` — a thin passthrough to `proton-drive auth`.
+
+Auth is left entirely to proton-drive (D3.3): it prints a URL to open on any
+device and persists the session to the OS keyring, so this works headlessly with
+no custom handling. We inherit stdio (no --json, no capture) so the interactive
+login URL reaches the user's terminal.
+"""
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+
+from protonfs.drive import DriveError, binary_path
+
+AUTH_SUBCOMMANDS = ("login", "logout", "status")
+
+
+def auth_passthrough(subcommand: str, binary: str | None = None, runner=subprocess.run) -> int:
+    """Invoke `proton-drive auth <subcommand>` with inherited stdio; return exit code.
+
+    Raises DriveError (rendered cleanly by the CLI error boundary) if the subcommand
+    is unknown or the proton-drive binary is not installed/on PATH -- so a first-time
+    user who runs `auth login` before `install-drive` gets an instructive message
+    instead of a raw FileNotFoundError.
+    """
+    if subcommand not in AUTH_SUBCOMMANDS:
+        raise ValueError(f"unknown auth subcommand: {subcommand!r}")
+    bin_path = binary or binary_path()
+    if shutil.which(bin_path) is None and not Path(bin_path).exists():
+        raise DriveError(
+            f"proton-drive binary not found: {bin_path}. Run `protonfs install-drive` first."
+        )
+    result = runner([bin_path, "auth", subcommand])
+    return result.returncode

protonfs/commands/ls.py

@@ -0,0 +1,61 @@
+# src/protonfs/commands/ls.py
+from __future__ import annotations
+
+from pathlib import Path
+
+from rich.console import Console
+from rich.table import Table
+
+from protonfs.context import RepoContext
+from protonfs.diff import classify, within_subpath
+from protonfs.drive import decrypted_name
+from protonfs.ignore import IgnoreMatcher
+from protonfs.localscan import scan
+
+
+def remote_rel_paths(ctx: RepoContext, subpath: str | None = None) -> dict[str, int]:
+    """Recursive files-only remote listing, scoped to `subpath` when given. rel_paths
+    are re-prefixed with the subpath so they match the index's repo-root-relative keys
+    (same convention as `refresh`)."""
+    remote_root = ctx.config.remote_root
+    if subpath:
+        remote_root = f"{remote_root}/{subpath}"
+    result = {e.rel_path: e.size for e in ctx.drive.walk(remote_root) if not e.is_dir}
+    if subpath:
+        result = {f"{subpath}/{rel}": size for rel, size in result.items()}
+    return result
+
+
+def render_ls(
+    ctx: RepoContext,
+    subpath: str | None,
+    remote: bool,
+    trash: bool,
+    console: Console,
+) -> None:
+    if trash:
+        entries = ctx.drive.list("/trash")
+        table = Table("name", "type")
+        for entry in entries:
+            name_val = decrypted_name(entry)
+            if name_val is not None:
+                table.add_row(name_val, entry.get("type", ""))
+        console.print(table)
+        return
+
+    ignore = IgnoreMatcher.from_file(ctx.root)
+    scan_root = Path(subpath) if subpath else Path(".")
+    local = scan(ctx.root, scan_root, ignore, ctx.index, low_io=ctx.config.defaults.low_io)
+    remote_map = remote_rel_paths(ctx, subpath) if remote else None
+    # classify reasons over the whole repo-wide index; when a subpath was given, the
+    # local scan and remote walk are scoped to it, so restrict the rows to that
+    # subpath too -- otherwise out-of-scope index entries (never scanned/walked) show
+    # up, and with a remote view are misread as remote-deleted.
+    diff_entries = [
+        e for e in classify(local, ctx.index, remote_map) if within_subpath(e.rel_path, subpath)
+    ]
+
+    table = Table("path", "state")
+    for entry in diff_entries:
+        table.add_row(entry.rel_path, entry.state.value)
+    console.print(table)

protonfs/commands/pull.py

@@ -0,0 +1,85 @@
+# src/protonfs/commands/pull.py
+from __future__ import annotations
+
+import datetime
+from pathlib import Path
+
+from protonfs.batching import batches, group_by_parent
+from protonfs.context import RepoContext
+from protonfs.diff import SyncState, classify
+from protonfs.drive import TransferResult
+from protonfs.ignore import IgnoreMatcher
+from protonfs.index import IndexEntry
+from protonfs.localscan import hash_file, scan
+
+
+def pull(
+    ctx: RepoContext,
+    subpath: str | None,
+    resolve: str | None,
+    dry_run: bool,
+    refresh: bool = False,
+) -> TransferResult:
+    ignore = IgnoreMatcher.from_file(ctx.root)
+    scan_root = Path(subpath) if subpath else Path(".")
+    local = scan(ctx.root, scan_root, ignore, ctx.index, low_io=ctx.config.defaults.low_io)
+    if refresh:
+        from protonfs.commands.refresh import refresh as refresh_index
+
+        # Reuse the scan we just did; on a dry run seed only in memory so the preview
+        # is accurate without persisting metadata-only entries to index.json.
+        refresh_index(ctx, subpath, prune=False, persist=not dry_run, local=local)
+    diff_entries = classify(local, ctx.index)
+
+    to_pull = [
+        e.rel_path
+        for e in diff_entries
+        if e.state in (SyncState.REMOTE_ONLY, SyncState.METADATA_ONLY)
+    ]
+    if dry_run or not to_pull:
+        return TransferResult(len(to_pull), 0, 0, [])
+
+    strategy = resolve or ctx.config.defaults.on_conflict
+    groups = group_by_parent(to_pull)
+    total = TransferResult(0, 0, 0, [])
+    now = datetime.datetime.now(datetime.timezone.utc).isoformat()
+
+    for parent, rels in groups.items():
+        local_folder = ctx.root if parent == "." else ctx.root / parent
+        local_folder.mkdir(parents=True, exist_ok=True)
+        for batch in batches(rels):
+            remote_paths = []
+            for rel in batch:
+                entry = ctx.index.get(rel)
+                default_remote = f"{ctx.config.remote_root}/{rel}"
+                remote_paths.append(entry.remote_path if entry else default_remote)
+            result = ctx.drive.download(remote_paths, local_folder, file_strategy=strategy)
+            total.transferred_items += result.transferred_items
+            total.skipped_items += result.skipped_items
+            total.failed_items += result.failed_items
+            total.failures += result.failures
+
+            failed_names = {f["name"] for f in result.failures}
+            for rel in batch:
+                if Path(rel).name in failed_names:
+                    continue
+                downloaded_path = ctx.root / rel
+                if not downloaded_path.exists():
+                    continue
+                stat = downloaded_path.stat()
+                prior = ctx.index.get(rel)
+                default_remote = f"{ctx.config.remote_root}/{rel}"
+                ctx.index.set(
+                    rel,
+                    IndexEntry(
+                        size=stat.st_size,
+                        mtime=stat.st_mtime,
+                        sha256=hash_file(downloaded_path),
+                        remote_path=prior.remote_path if prior else default_remote,
+                        origin_device=prior.origin_device if prior else "unknown",
+                        local_state="present",
+                        last_synced=now,
+                    ),
+                )
+    ctx.index.save()
+    return total

protonfs/commands/push.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import datetime
+from pathlib import Path
+
+from protonfs.batching import batches, group_by_parent
+from protonfs.context import RepoContext
+from protonfs.diff import SyncState, classify
+from protonfs.drive import DriveError, TransferResult
+from protonfs.ignore import IgnoreMatcher
+from protonfs.index import IndexEntry
+from protonfs.localscan import scan
+
+
+def _ensure_remote_dir(ctx: RepoContext, remote_dir: str) -> None:
+    root = ctx.config.remote_root.rstrip("/")
+    if not remote_dir.startswith(root):
+        return
+    relative = remote_dir[len(root) :].strip("/")
+    if not relative:
+        return
+    current = root
+    for segment in relative.split("/"):
+        try:
+            ctx.drive.create_folder(current, segment)
+        except DriveError:
+            pass  # already exists -- a real failure will surface on the upload call below
+        current = f"{current}/{segment}"
+
+
+def push(
+    ctx: RepoContext,
+    subpath: str | None,
+    resolve: str | None,
+    dry_run: bool,
+) -> TransferResult:
+    ignore = IgnoreMatcher.from_file(ctx.root)
+    scan_root = Path(subpath) if subpath else Path(".")
+    local = scan(ctx.root, scan_root, ignore, ctx.index, low_io=ctx.config.defaults.low_io)
+    diff_entries = classify(local, ctx.index)
+
+    to_push = [
+        e.rel_path for e in diff_entries if e.state in (SyncState.LOCAL_ONLY, SyncState.CONFLICT)
+    ]
+    if dry_run or not to_push:
+        return TransferResult(len(to_push), 0, 0, [])
+
+    # D2.1: default push applies NO conflict strategy so the CLI surfaces conflicts as
+    # named per-file failures (never a silent skip that we'd falsely index). A strategy
+    # is used only when the user explicitly asks via --resolve.
+    strategy = resolve
+    groups = group_by_parent(to_push)
+    total = TransferResult(0, 0, 0, [])
+    now = datetime.datetime.now(datetime.timezone.utc).isoformat()
+
+    for parent, rels in groups.items():
+        remote_parent = (
+            f"{ctx.config.remote_root}/{parent}" if parent != "." else ctx.config.remote_root
+        )
+        _ensure_remote_dir(ctx, remote_parent)
+        for batch in batches(rels):
+            local_paths = [ctx.root / rel for rel in batch]
+            result = ctx.drive.upload(local_paths, remote_parent, file_strategy=strategy)
+            total.transferred_items += result.transferred_items
+            total.skipped_items += result.skipped_items
+            total.failed_items += result.failed_items
+            total.failures += result.failures
+
+            # D2.1: a skip is reported only as an aggregate count, so we cannot tell
+            # WHICH files in the batch were skipped. Rather than falsely record an
+            # unconfirmed hash, index none of this batch's non-failed files and leave
+            # them for the next push.
+            if result.skipped_items > 0:
+                continue
+            failed_names = {f["name"] for f in result.failures}
+            for rel in batch:
+                if Path(rel).name in failed_names:
+                    continue
+                entry = local[rel]
+                remote_path = f"{remote_parent}/{Path(rel).name}"
+                ctx.index.set(
+                    rel,
+                    IndexEntry(
+                        size=entry.size,
+                        mtime=entry.mtime,
+                        sha256=entry.sha256,
+                        remote_path=remote_path,
+                        origin_device=ctx.config.device_id,
+                        local_state="present",
+                        last_synced=now,
+                    ),
+                )
+    ctx.index.save()
+    return total

protonfs/commands/refresh.py

@@ -0,0 +1,86 @@
+# src/protonfs/commands/refresh.py
+from __future__ import annotations
+
+import datetime
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from protonfs.context import RepoContext
+from protonfs.diff import SyncState, classify, within_subpath
+from protonfs.ignore import IgnoreMatcher
+from protonfs.index import IndexEntry
+from protonfs.localscan import ScanEntry, scan
+
+
+@dataclass
+class RefreshResult:
+    seeded: int = 0
+    remote_changed: int = 0
+    remote_deleted: int = 0
+    pruned: int = 0
+    changed_paths: list[str] = field(default_factory=list)
+    deleted_paths: list[str] = field(default_factory=list)
+
+
+def refresh(
+    ctx: RepoContext,
+    subpath: str | None,
+    prune: bool,
+    persist: bool = True,
+    local: dict[str, ScanEntry] | None = None,
+) -> RefreshResult:
+    remote_root = ctx.config.remote_root
+    if subpath:
+        remote_root = f"{remote_root}/{subpath}"
+    entries = ctx.drive.walk(remote_root)
+    remote = {e.rel_path: e.size for e in entries if not e.is_dir}
+    # rel_paths from the walk are relative to remote_root; if a subpath was given,
+    # re-prefix so keys match the index's repo-root-relative rel_paths.
+    if subpath:
+        remote = {f"{subpath}/{rel}": size for rel, size in remote.items()}
+
+    # `local` may be supplied by a caller (e.g. pull --refresh) that already scanned
+    # the same tree, so we don't pay for a second recursive walk + re-hash.
+    if local is None:
+        ignore = IgnoreMatcher.from_file(ctx.root)
+        scan_root = Path(subpath) if subpath else Path(".")
+        local = scan(ctx.root, scan_root, ignore, ctx.index, low_io=ctx.config.defaults.low_io)
+    diff_entries = classify(local, ctx.index, remote)
+
+    result = RefreshResult()
+    now = datetime.datetime.now(datetime.timezone.utc).isoformat()
+
+    for rel, size in remote.items():
+        if ctx.index.get(rel) is None and rel not in local:
+            ctx.index.set(
+                rel,
+                IndexEntry(
+                    size=size,
+                    mtime=0.0,
+                    sha256="",
+                    remote_path=f"{ctx.config.remote_root}/{rel}",
+                    origin_device="unknown",
+                    local_state="metadata-only",
+                    last_synced=now,
+                ),
+            )
+            result.seeded += 1
+
+    for entry in diff_entries:
+        # A subpath-scoped walk only saw files under `subpath`; index entries outside
+        # it were never checked, so their absence from `remote` is not a deletion.
+        if not within_subpath(entry.rel_path, subpath):
+            continue
+        if entry.state == SyncState.REMOTE_CHANGED:
+            result.remote_changed += 1
+            result.changed_paths.append(entry.rel_path)
+        elif entry.state == SyncState.REMOTE_DELETED:
+            result.remote_deleted += 1
+            result.deleted_paths.append(entry.rel_path)
+            if prune:
+                ctx.index.remove(entry.rel_path)
+                result.pruned += 1
+
+    if persist:
+        ctx.index.save()
+    return result

protonfs/commands/restore.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from protonfs.context import RepoContext
+
+
+def restore(ctx: RepoContext, rel_path: str) -> None:
+    entry = ctx.index.get(rel_path)
+    remote_path = entry.remote_path if entry else f"{ctx.config.remote_root}/{rel_path}"
+    ctx.drive.restore([remote_path])

protonfs/commands/rm.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from pathlib import PurePosixPath
+
+import click
+
+from protonfs.context import RepoContext
+from protonfs.drive import decrypted_name
+
+
+def rm(ctx: RepoContext, rel_path: str, recursive: bool, force: bool, confirmed: bool) -> None:
+    local_target = ctx.root / rel_path
+    if local_target.is_dir() and not recursive:
+        raise click.ClickException(
+            f"'{rel_path}' is a directory; pass -r/--recursive to remove it."
+        )
+
+    if not confirmed:
+        kind = "permanently delete" if force else "trash"
+        click.confirm(f"{kind.capitalize()} '{rel_path}' on Drive?", abort=True)
+
+    entry = ctx.index.get(rel_path)
+    remote_path = entry.remote_path if entry else f"{ctx.config.remote_root}/{rel_path}"
+
+    ctx.drive.trash([remote_path])
+    if force:
+        # D2.2: permanent delete works only against /trash/<basename>, and with
+        # duplicate basenames the CLI deletes one arbitrarily. So only delete when
+        # exactly one trashed item carries this basename; otherwise leave it trashed
+        # (still reversible) and tell the user to resolve it manually.
+        name = PurePosixPath(remote_path).name
+        matches = [
+            entry for entry in ctx.drive.list("/trash") if decrypted_name(entry) == name
+        ]
+        if len(matches) == 1:
+            ctx.drive.delete([f"/trash/{name}"])
+        elif len(matches) > 1:
+            click.echo(
+                f"{len(matches)} items named '{name}' are in trash; protonfs can't "
+                f"safely pick yours for permanent deletion. Resolve it via the Proton "
+                f"Drive app/web, or leave it trashed (it is already reversible)."
+            )
+        else:
+            click.echo(
+                f"'{name}' was trashed but could not be found in trash for permanent "
+                f"deletion (it may still be processing); it remains trashed and reversible."
+            )
+
+    for indexed_rel in list(ctx.index.all()):
+        if indexed_rel == rel_path or indexed_rel.startswith(rel_path + "/"):
+            ctx.index.remove(indexed_rel)
+    ctx.index.save()