browser.py

"""Curses-based SMB share browser and file viewer."""

from __future__ import annotations

import curses
import fnmatch
import ntpath
import re
import textwrap
from pathlib import Path

from cursor_position import CursorPosition
from keyboard import KeyboardInputMixin
from protocol import RemoteEntry, SmbClient, SmbError, TreeFile, UploadCancelled

DISPLAY_CONFIRM_THRESHOLD = 1024 * 1024
SESSION_ERROR_MARKER = "SMB SessionError"
SESSION_ERROR_COLOR_PAIR = 1
SENSITIVE_FILE_COLOR_PAIR = 2
MODE_LIVE_COLOR_PAIR = 3
MODE_OPSEC_COLOR_PAIR = 4
GREP_MATCH_COLOR_PAIR = 5
GREP_SELECTED_MATCH_COLOR_PAIR = 6
MODES = ("LIVE", "OPSEC")
SENSITIVE_FILENAME_MARKERS = (
    "_history",
    ".cert",
    ".dmp",
    ".kdbx",
    ".ova",
    ".pem",
    ".ppk",
    ".vmdk",
    "password",
    "passwd",
    "id_rsa",
    "web.config",
)
HELP_CONTENT = """Keyboard shortcuts

[UP]/[k]            Move up
[DOWN]/[j]          Move down
[PAGE UP]           Move up one screen
[PAGE DOWN]         Move down one screen
[HOME]/[g]          Jump to the beginning
[END]/[G]           Jump to the end
[ENTER]             Open the selected item
[BACKSPACE]         Return to the parent or previous view
[d]                 Download the selected file
[SUPPR]             Delete the selected or open file
[/]                 Open the command prompt
[h]                 Display this help
[r]                 Refresh the browser listing
[m]                 Toggle between LIVE and OPSEC modes
[n]                 Jump to the next /grep match in a file preview
[ESC]/[q]           Close the viewer; [q] quits from the browser

Commands

/get [<filename>]   Download the selected/open file or a named file
/download, /dl      Aliases for /get
/put <local-path>   Upload a local file to the current directory
/upload <local-path>
                    Alias for /put
/filter <pattern>   Filter the current listing by regex or glob
/filter             Clear the active filter
/refresh            Refetch the current directory and update the cache
/mode <mode>        Switch to LIVE or OPSEC mode
/grep <regex>       Highlight regex matches in the open file preview
/grep               Clear preview match highlighting
/tree               Open an interactive recursive file listing
/tree_download      Recursively download the current directory
/rm [<filename>]    Delete the selected/open file or a named file
/delete [<filename>]
                    Alias for /rm
/mkdir <directory>  Create a directory in the current directory
/rmdir [<directory>]
                    Remove a selected/named empty directory
/help               Display this help
/exit, /quit        Exit SMBLoot

Preview option

--auto-loot-preview Automatically download each successfully previewed file
--highlight-sensitive-files Display potentially sensitive files in orange
"""


class SmbBrowser(KeyboardInputMixin):
    def __init__(
        self,
        screen: curses.window,
        client: SmbClient,
        start_share: str | None = None,
        start_path: str = "",
        loot_dir: str = "loot",
        *,
        auto_loot_preview: bool = False,
        highlight_sensitive_files: bool = True,
        mode: str = "LIVE",
        tree_workers: int = 4,
    ) -> None:
        self.screen = screen
        self.client = client
        self.loot_dir = Path(loot_dir).expanduser().resolve()
        self.auto_loot_preview = auto_loot_preview
        self.highlight_sensitive_files = highlight_sensitive_files
        self.mode = mode.upper()
        if self.mode not in MODES:
            raise ValueError(f"mode must be one of: {', '.join(MODES)}")
        if not 1 <= tree_workers <= 16:
            raise ValueError("tree_workers must be between 1 and 16")
        self.tree_workers = tree_workers
        self.share = start_share or None
        self.path = self._normalise_path(start_path) if self.share else ""
        self.all_entries: list[RemoteEntry] = []
        self.entries: list[RemoteEntry] = []
        self.selected = 0
        self.top = 0
        self.cursor_positions: dict[tuple[str | None, str], CursorPosition] = {}
        self.filter_pattern = ""
        self.filter_regex: re.Pattern[str] | None = None
        self.filter_kind = ""
        self.grep_pattern = ""
        self.grep_regex: re.Pattern[str] | None = None
        self.grep_match_index = -1
        self.entry_cache: dict[
            tuple[str | None, str],
            list[RemoteEntry],
        ] = {}
        self.status = "Loading..."
        self.view_path: str | None = None
        self.view_content = ""
        self.view_size = 0
        self.view_top = 0
        self.view_kind = "File"
        self.view_share: str | None = None
        self.view_remote_path: str | None = None
        self.view_status = ""
        self.tree_files: list[TreeFile] = []
        self.tree_errors: list[str] = []
        self.tree_selected = 0
        self.exit_requested = False
        self.help_return_view: (
            tuple[
                str,
                str,
                int,
                int,
                str,
                str | None,
                str | None,
                str,
                list[TreeFile],
                list[str],
                int,
            ]
            | None
        ) = None
        self.session_error_attr = curses.A_BOLD
        self.sensitive_file_attr = curses.A_BOLD
        self.live_mode_attr = curses.A_BOLD
        self.opsec_mode_attr = curses.A_BOLD
        self.grep_match_attr = curses.A_REVERSE | curses.A_BOLD
        self.grep_selected_match_attr = (
            curses.A_REVERSE | curses.A_BOLD | curses.A_UNDERLINE
        )

    @staticmethod
    def _normalise_path(path: str) -> str:
        path = ntpath.normpath((path or "").replace("/", "\\"))
        return "" if path == "." else path.strip("\\")

    @property
    def location(self) -> str:
        return self.client.unc_path(self.share, self.path)

    @property
    def _location_key(self) -> tuple[str | None, str]:
        return self.share, self.path

    def _remember_cursor(self) -> None:
        selected_name = None
        if 0 <= self.selected < len(self.entries):
            selected_name = self.entries[self.selected].name
        self.cursor_positions[self._location_key] = CursorPosition(
            selected_name=selected_name,
            selected_index=self.selected,
            row_offset=max(0, self.selected - self.top),
        )

    def _restore_cursor(self) -> None:
        position = self.cursor_positions.get(self._location_key)
        if position is None or not self.entries:
            return

        selected = min(position.selected_index, len(self.entries) - 1)
        if position.selected_name is not None:
            selected_name = position.selected_name.casefold()
            selected = next(
                (
                    index
                    for index, entry in enumerate(self.entries)
                    if entry.name.casefold() == selected_name
                ),
                selected,
            )

        body_height = max(1, self.screen.getmaxyx()[0] - 3)
        row_offset = min(position.row_offset, body_height - 1)
        max_top = max(0, len(self.entries) - body_height)
        self.selected = selected
        self.top = max(0, min(selected - row_offset, max_top))

    def _safe_addstr(
        self, row: int, col: int, text: str, attr: int = curses.A_NORMAL
    ) -> None:
        height, width = self.screen.getmaxyx()
        if row < 0 or row >= height or col >= width or width <= 0:
            return
        try:
            self.screen.addnstr(row, col, text, max(0, width - col - 1), attr)
        except curses.error:
            pass

    def _draw_bar(self, row: int, text: str, attr: int) -> None:
        _, width = self.screen.getmaxyx()
        self._safe_addstr(row, 0, text.ljust(max(0, width - 1)), attr)

    @staticmethod
    def _is_session_error(message: str) -> bool:
        return SESSION_ERROR_MARKER.casefold() in message.casefold()

    def _message_attr(self, message: str, default: int) -> int:
        if self._is_session_error(message):
            return self.session_error_attr
        return default

    def _initialise_colors(self) -> None:
        try:
            curses.start_color()
            try:
                curses.use_default_colors()
                background = -1
            except curses.error:
                background = curses.COLOR_BLACK
            curses.init_pair(
                SESSION_ERROR_COLOR_PAIR,
                curses.COLOR_RED,
                background,
            )
            self.session_error_attr = (
                curses.color_pair(SESSION_ERROR_COLOR_PAIR) | curses.A_BOLD
            )
            orange = 208 if getattr(curses, "COLORS", 0) >= 256 else curses.COLOR_YELLOW
            curses.init_pair(
                SENSITIVE_FILE_COLOR_PAIR,
                orange,
                background,
            )
            self.sensitive_file_attr = curses.color_pair(SENSITIVE_FILE_COLOR_PAIR)
            curses.init_pair(
                MODE_LIVE_COLOR_PAIR,
                curses.COLOR_RED,
                background,
            )
            self.live_mode_attr = (
                curses.color_pair(MODE_LIVE_COLOR_PAIR) | curses.A_BOLD
            )
            curses.init_pair(
                MODE_OPSEC_COLOR_PAIR,
                curses.COLOR_GREEN,
                background,
            )
            self.opsec_mode_attr = (
                curses.color_pair(MODE_OPSEC_COLOR_PAIR) | curses.A_BOLD
            )
            curses.init_pair(
                GREP_MATCH_COLOR_PAIR,
                curses.COLOR_BLACK,
                curses.COLOR_YELLOW,
            )
            self.grep_match_attr = (
                curses.color_pair(GREP_MATCH_COLOR_PAIR) | curses.A_BOLD
            )
            curses.init_pair(
                GREP_SELECTED_MATCH_COLOR_PAIR,
                curses.COLOR_BLACK,
                curses.COLOR_CYAN,
            )
            self.grep_selected_match_attr = (
                curses.color_pair(GREP_SELECTED_MATCH_COLOR_PAIR) | curses.A_BOLD
            )
        except curses.error:
            pass

    def _mode_badge(self) -> tuple[str, int]:
        if self.mode == "LIVE":
            return "[LIVE]", self.live_mode_attr
        return "[OPSEC]", self.opsec_mode_attr

    def _draw_mode_badge(self) -> None:
        _, width = self.screen.getmaxyx()
        badge, attr = self._mode_badge()
        self._safe_addstr(0, max(0, width - len(badge) - 1), badge, attr)

    def _draw_header(self, text: str) -> None:
        self._draw_bar(0, text, curses.A_REVERSE)
        self._draw_mode_badge()

    def _set_mode(self, mode: str) -> None:
        normalised_mode = mode.upper()
        if normalised_mode not in MODES:
            raise ValueError(f"mode must be one of: {', '.join(MODES)}")

        self.mode = normalised_mode
        if self._entry_cache_key not in self.entry_cache:
            self.entry_cache[self._entry_cache_key] = list(self.all_entries)

        message = f"Mode changed to {self.mode}"
        if self.view_path is None:
            self.status = message
        else:
            self.view_status = message

    def _toggle_mode(self) -> None:
        self._set_mode("OPSEC" if self.mode == "LIVE" else "LIVE")

    @staticmethod
    def _is_sensitive_filename(filename: str) -> bool:
        folded_name = filename.casefold()
        return any(marker in folded_name for marker in SENSITIVE_FILENAME_MARKERS)

    def _file_attr(self, filename: str, *, selected: bool) -> int:
        attr = curses.A_REVERSE if selected else curses.A_NORMAL
        if self.highlight_sensitive_files and self._is_sensitive_filename(filename):
            attr |= self.sensitive_file_attr
        return attr

    @staticmethod
    def _compile_filter(pattern: str) -> tuple[re.Pattern[str], str]:
        try:
            return re.compile(pattern, re.IGNORECASE), "regex"
        except re.error:
            if not any(character in pattern for character in "*?["):
                raise
            return re.compile(fnmatch.translate(pattern), re.IGNORECASE), "glob"

    def _filter_entries(self) -> list[RemoteEntry]:
        if self.filter_regex is None:
            return list(self.all_entries)
        return [
            entry
            for entry in self.all_entries
            if entry.is_parent or self.filter_regex.search(entry.name)
        ]

    def _listing_counts(self) -> tuple[int, int, str]:
        parent_count = sum(entry.is_parent for entry in self.all_entries)
        visible_parent_count = sum(entry.is_parent for entry in self.entries)
        total = len(self.all_entries) - parent_count
        visible = len(self.entries) - visible_parent_count
        return visible, total, "shares" if self.share is None else "entries"

    @staticmethod
    def _folder_file_counts(entries: list[RemoteEntry]) -> tuple[int, int]:
        folders = sum(
            entry.is_directory and not entry.is_parent and not entry.is_share
            for entry in entries
        )
        files = sum(
            not entry.is_directory and not entry.is_parent and not entry.is_share
            for entry in entries
        )
        return folders, files

    @staticmethod
    def _format_item_counts(
        file_count: int,
        *,
        folder_count: int | None = None,
        total_file_count: int | None = None,
        total_folder_count: int | None = None,
    ) -> str:
        def count_text(count: int, total: int | None, noun: str) -> str:
            amount = str(count) if total is None else f"{count}/{total}"
            suffix = "" if count == 1 and total is None else "s"
            return f"{amount} {noun}{suffix}"

        parts: list[str] = []
        if folder_count is not None:
            parts.append(count_text(folder_count, total_folder_count, "folder"))
        parts.append(count_text(file_count, total_file_count, "file"))
        return ", ".join(parts)

    def _listing_status(self) -> str:
        visible, total, noun = self._listing_counts()
        if self.share is not None:
            visible_folders, visible_files = self._folder_file_counts(self.entries)
            total_folders, total_files = self._folder_file_counts(self.all_entries)
            if self.filter_regex is None:
                return self._format_item_counts(
                    visible_files,
                    folder_count=visible_folders,
                )
            counts = self._format_item_counts(
                visible_files,
                folder_count=visible_folders,
                total_file_count=total_files,
                total_folder_count=total_folders,
            )
            return f"{counts} ({self.filter_kind} filter: {self.filter_pattern})"
        if self.filter_regex is None:
            return f"{total} {noun}"
        return (
            f"{visible}/{total} {noun} "
            f"({self.filter_kind} filter: {self.filter_pattern})"
        )

    def _set_filter(self, pattern: str) -> None:
        selected_name = None
        if 0 <= self.selected < len(self.entries):
            selected_name = self.entries[self.selected].name

        if pattern:
            try:
                compiled, kind = self._compile_filter(pattern)
            except re.error as exc:
                self.status = f"Invalid filter regex: {exc}"
                return
            self.filter_pattern = pattern
            self.filter_regex = compiled
            self.filter_kind = kind
        else:
            self.filter_pattern = ""
            self.filter_regex = None
            self.filter_kind = ""

        self.entries = self._filter_entries()
        self.selected = 0
        self.top = 0
        if selected_name is not None:
            selected_folded = selected_name.casefold()
            self.selected = next(
                (
                    index
                    for index, entry in enumerate(self.entries)
                    if entry.name.casefold() == selected_folded
                ),
                0,
            )
        self.status = self._listing_status()

    def _draw_browser(self) -> None:
        height, _ = self.screen.getmaxyx()
        self._draw_header(f" SMB browser  {self.location}")
        body_height = max(1, height - 3)

        self.top = min(self.top, self.selected)
        if self.selected >= self.top + body_height:
            self.top = self.selected - body_height + 1

        for row, index in enumerate(
            range(self.top, min(len(self.entries), self.top + body_height)), 1
        ):
            entry = self.entries[index]
            prefix = (
                " s  " if entry.is_share else " d  " if entry.is_directory else " f  "
            )
            if entry.is_directory:
                attr = (
                    curses.A_REVERSE
                    if index == self.selected
                    else curses.A_NORMAL | curses.A_BOLD
                )
            else:
                attr = self._file_attr(entry.name, selected=index == self.selected)
            self._safe_addstr(row, 0, prefix + entry.label, attr)

        if not self.entries:
            self._safe_addstr(2, 2, "(no entries)")

        self._draw_bar(
            height - 2,
            " [UP]/[DOWN] move   [ENTER] open   [d] download   "
            "[SUPPR] delete   [/] commands   [m] mode   [h] help   [q] quit",
            curses.A_REVERSE,
        )
        self._draw_bar(
            height - 1,
            f" {self.status}",
            self._message_attr(self.status, curses.A_DIM),
        )

    def _wrapped_content(self, width: int) -> list[str]:
        wrap_width = max(1, width - 1)
        result: list[str] = []
        for line in self.view_content.expandtabs(4).split("\n"):
            result.extend(
                textwrap.wrap(
                    line,
                    width=wrap_width,
                    replace_whitespace=False,
                    drop_whitespace=False,
                    break_long_words=True,
                    break_on_hyphens=False,
                )
                or [""]
            )
        return result

    def _draw_preview_line(
        self,
        row: int,
        line: str,
        matches: list[tuple[int, int, int]] | None = None,
    ) -> None:
        if self.grep_regex is None:
            self._safe_addstr(row, 0, line, curses.A_NORMAL)
            return

        if matches is None:
            matches = [
                (index, match.start(), match.end())
                for index, match in enumerate(self.grep_regex.finditer(line))
                if match.end() > match.start()
            ]
        column = 0
        for match_index, start, end in matches:
            if start > column:
                self._safe_addstr(
                    row,
                    column,
                    line[column:start],
                    curses.A_NORMAL,
                )
            self._safe_addstr(
                row,
                start,
                line[start:end],
                (
                    self.grep_selected_match_attr
                    if match_index == self.grep_match_index
                    else self.grep_match_attr
                ),
            )
            column = end
        if column < len(line):
            self._safe_addstr(row, column, line[column:], curses.A_NORMAL)

    def _set_grep(self, pattern: str) -> None:
        if self.view_kind != "File":
            self.view_status = "/grep is only available in a file preview"
            return
        if not pattern:
            self.grep_pattern = ""
            self.grep_regex = None
            self.view_status = "Grep highlighting cleared"
            return
        try:
            compiled = re.compile(pattern, re.IGNORECASE)
        except re.error as exc:
            self.view_status = f"Invalid grep regex: {exc}"
            return

        self.grep_pattern = pattern
        self.grep_regex = compiled
        match_lines = self._grep_match_lines()
        if match_lines:
            self.grep_match_index = 0
            self._jump_to_grep_match(match_lines)
        else:
            self.grep_match_index = -1
            self.view_status = f"Grep: 0 matches for {pattern!r}"

    def _grep_matches(
        self,
        lines: list[str] | None = None,
    ) -> list[tuple[int, int, int]]:
        if self.grep_regex is None:
            return []
        if lines is None:
            _, width = self.screen.getmaxyx()
            lines = self._wrapped_content(width)
        matches: list[tuple[int, int, int]] = []
        for line_index, line in enumerate(lines):
            matches.extend(
                (line_index, match.start(), match.end())
                for match in self.grep_regex.finditer(line)
                if match.end() > match.start()
            )
        return matches

    def _grep_match_lines(self) -> list[int]:
        return [line_index for line_index, _, _ in self._grep_matches()]

    def _jump_to_grep_match(self, match_lines: list[int]) -> None:
        height, _ = self.screen.getmaxyx()
        body_height = max(1, height - 3)
        match_line = match_lines[self.grep_match_index]
        self.view_top = max(0, match_line - body_height // 2)
        self.view_status = (
            f"Grep: match {self.grep_match_index + 1}/{len(match_lines)} "
            f"for {self.grep_pattern!r}"
        )

    def _next_grep_match(self) -> None:
        if self.grep_regex is None:
            self.view_status = "No active grep; use /grep <regex>"
            return
        match_lines = self._grep_match_lines()
        if not match_lines:
            self.grep_match_index = -1
            self.view_status = f"Grep: 0 matches for {self.grep_pattern!r}"
            return
        self.grep_match_index = (self.grep_match_index + 1) % len(match_lines)
        self._jump_to_grep_match(match_lines)

    def _clear_grep(self) -> None:
        self.grep_pattern = ""
        self.grep_regex = None
        self.grep_match_index = -1

    def _draw_viewer(self) -> None:
        if self.view_kind == "Tree":
            self._draw_tree_viewer()
            return

        height, width = self.screen.getmaxyx()
        assert self.view_path is not None
        lines = self._wrapped_content(width)
        body_height = max(1, height - 3)
        max_top = max(0, len(lines) - body_height)
        self.view_top = max(0, min(self.view_top, max_top))

        self._draw_header(f" {self.view_kind}  {self.view_path}")
        grep_matches_by_line: dict[int, list[tuple[int, int, int]]] = {}
        if self.view_kind == "File":
            for match_index, (line_index, start, end) in enumerate(
                self._grep_matches(lines)
            ):
                grep_matches_by_line.setdefault(line_index, []).append(
                    (match_index, start, end)
                )
        visible_lines = lines[self.view_top : self.view_top + body_height]
        for offset, line in enumerate(visible_lines):
            row = offset + 1
            line_index = self.view_top + offset
            if self.view_kind == "File":
                self._draw_preview_line(
                    row,
                    line,
                    grep_matches_by_line.get(line_index, []),
                )
            else:
                attr = self._message_attr(line, curses.A_NORMAL)
                self._safe_addstr(row, 0, line, attr)

        percent = 100 if not max_top else int(100 * self.view_top / max_top)
        if self.view_kind == "Help":
            self._draw_bar(
                height - 2,
                f" [UP]/[DOWN] scroll   [ESC]/[q] back   {percent:3d}%",
                curses.A_REVERSE,
            )
            self._draw_bar(height - 1, f" {self.view_status}", curses.A_DIM)
        else:
            self._draw_bar(
                height - 2,
                f" [UP]/[DOWN] scroll   [n] next match   [SUPPR] delete   "
                f"/get   /put [TAB]   "
                f"[ESC]/[q] back   {percent:3d}%",
                curses.A_REVERSE,
            )
            status = f"  {self.view_status}" if self.view_status else ""
            self._draw_bar(
                height - 1,
                f" {self.view_size} bytes{status}",
                self._message_attr(self.view_status, curses.A_DIM),
            )

    def _tree_display_lines(self) -> list[tuple[str, int | None]]:
        lines: list[tuple[str, int | None]] = [
            (
                (
                    f"{self._format_item_counts(len(self.tree_files))}, "
                    f"{SmbClient._format_size(self.view_size)} total"
                ),
                None,
            ),
            ("", None),
        ]
        lines.extend(
            (
                (
                    f"{SmbClient._format_size(item.size):>10} "
                    f"{item.date}  "
                    f"{self._relative_tree_path(item.path)}"
                ),
                index,
            )
            for index, item in enumerate(self.tree_files)
        )
        if not self.tree_files:
            lines.append(("(no files)", None))
        if self.tree_errors:
            lines.extend(
                [
                    ("", None),
                    (f"Errors ({len(self.tree_errors)}):", None),
                    *((error, None) for error in self.tree_errors),
                ]
            )
        return lines

    def _draw_tree_viewer(self) -> None:
        height, _ = self.screen.getmaxyx()
        assert self.view_path is not None
        lines = self._tree_display_lines()
        body_height = max(1, height - 3)
        selected_line = 2 + self.tree_selected if self.tree_files else 0

        if selected_line < self.view_top:
            self.view_top = selected_line
        elif selected_line >= self.view_top + body_height:
            self.view_top = selected_line - body_height + 1
        max_top = max(0, len(lines) - body_height)
        self.view_top = max(0, min(self.view_top, max_top))

        self._draw_header(f" Tree  {self.view_path}")
        visible = lines[self.view_top : self.view_top + body_height]
        for row, (line, file_index) in enumerate(visible, 1):
            attr = self._message_attr(line, curses.A_NORMAL)
            if file_index is not None and self.highlight_sensitive_files:
                filename = ntpath.basename(self.tree_files[file_index].path)
                if self._is_sensitive_filename(filename):
                    attr |= self.sensitive_file_attr
            if file_index == self.tree_selected:
                attr |= curses.A_REVERSE
            self._safe_addstr(row, 0, line, attr)

        self._draw_bar(
            height - 2,
            " [UP]/[DOWN] select   [ENTER] open   [d] download   "
            "[SUPPR] delete   [h] help   [ESC]/[q] back",
            curses.A_REVERSE,
        )
        self._draw_bar(
            height - 1,
            f" {self.view_status}",
            self._message_attr(self.view_status, curses.A_DIM),
        )

    def draw(self) -> None:
        self.screen.erase()
        if self.view_path is None:
            self._draw_browser()
        else:
            self._draw_viewer()
        self.screen.refresh()

    def _show_help(self) -> None:
        if self.view_kind == "Help":
            self.view_top = 0
            return

        if self.view_path is not None:
            self.help_return_view = (
                self.view_path,
                self.view_content,
                self.view_size,
                self.view_top,
                self.view_kind,
                self.view_share,
                self.view_remote_path,
                self.view_status,
                list(self.tree_files),
                list(self.tree_errors),
                self.tree_selected,
            )
        else:
            self.help_return_view = None

        self.view_path = "Commands and keyboard shortcuts"
        self.view_content = HELP_CONTENT
        self.view_size = 0
        self.view_top = 0
        self.view_kind = "Help"
        self.view_share = None
        self.view_remote_path = None
        self.view_status = "Press [ESC], [BACKSPACE], or [q] to return"
        self.tree_files = []
        self.tree_errors = []
        self.tree_selected = 0

    def _close_viewer(self) -> None:
        if self.view_kind == "Help" and self.help_return_view is not None:
            (
                self.view_path,
                self.view_content,
                self.view_size,
                self.view_top,
                self.view_kind,
                self.view_share,
                self.view_remote_path,
                self.view_status,
                self.tree_files,
                self.tree_errors,
                self.tree_selected,
            ) = self.help_return_view
            self.help_return_view = None
            return

        self.view_path = None
        self.view_content = ""
        self.view_size = 0
        self.view_top = 0
        self.view_kind = "File"
        self.view_share = None
        self.view_remote_path = None
        self.view_status = ""
        self._clear_grep()
        self.tree_files = []
        self.tree_errors = []
        self.tree_selected = 0
        self.help_return_view = None

    @property
    def _entry_cache_key(self) -> tuple[str | None, str]:
        return self._make_entry_cache_key(self.share, self.path)

    @staticmethod
    def _make_entry_cache_key(
        share: str | None,
        path: str,
    ) -> tuple[str | None, str]:
        share = share.casefold() if share is not None else None
        path = ntpath.normcase(ntpath.normpath(path or "."))
        return share, path

    def _show_cached_entries_if_current(
        self,
        cache_key: tuple[str | None, str],
    ) -> None:
        if cache_key != self._entry_cache_key:
            return
        self.all_entries = list(self.entry_cache[cache_key])
        self.entries = self._filter_entries()
        self.selected = min(self.selected, max(0, len(self.entries) - 1))

    def _upsert_cached_entry(
        self,
        share: str,
        directory: str,
        entry: RemoteEntry,
    ) -> None:
        cache_key = self._make_entry_cache_key(share, directory)
        cached_entries = list(self.entry_cache.get(cache_key, self.all_entries))
        folded_name = entry.name.casefold()
        cached_entries = [
            cached
            for cached in cached_entries
            if cached.is_parent or cached.name.casefold() != folded_name
        ]
        cached_entries.append(entry)
        cached_entries.sort(
            key=lambda cached: (
                not cached.is_parent,
                not cached.is_directory,
                cached.name.casefold(),
            )
        )
        self.entry_cache[cache_key] = cached_entries
        self._show_cached_entries_if_current(cache_key)

    def _remove_cached_entry(self, share: str, remote_path: str) -> None:
        directory = ntpath.dirname(remote_path)
        filename = ntpath.basename(remote_path).casefold()
        cache_key = self._make_entry_cache_key(share, directory)
        cached_entries = self.entry_cache.get(cache_key)
        if cached_entries is None:
            return
        self.entry_cache[cache_key] = [
            entry
            for entry in cached_entries
            if entry.is_parent or entry.name.casefold() != filename
        ]
        self._show_cached_entries_if_current(cache_key)

    def _discard_cached_subtree(self, share: str, path: str) -> None:
        subtree_key = self._make_entry_cache_key(share, path)
        subtree_share, subtree_path = subtree_key
        prefix = subtree_path + "\\"
        for cache_key in list(self.entry_cache):
            cached_share, cached_path = cache_key
            if cached_share == subtree_share and (
                cached_path == subtree_path or cached_path.startswith(prefix)
            ):
                del self.entry_cache[cache_key]

    def refresh(self, *, force: bool = False) -> None:
        self.status = f"Reading {self.location}..."
        self.draw()
        try:
            cache_key = self._entry_cache_key
            cached_entries = self.entry_cache.get(cache_key)
            if self.mode == "OPSEC" and not force and cached_entries is not None:
                self.all_entries = list(cached_entries)
            else:
                if self.share is None:
                    self.all_entries = self.client.list_shares()
                else:
                    self.all_entries = [
                        RemoteEntry("..", True, is_parent=True),
                        *self.client.list_directory(self.share, self.path),
                    ]
                self.entry_cache[cache_key] = list(self.all_entries)
            self.entries = self._filter_entries()
            self.selected = min(self.selected, max(0, len(self.entries) - 1))
            self.status = self._listing_status()
        except SmbError as exc:
            self.all_entries = []
            self.entries = []
            self.selected = 0
            self.status = f"Error: {exc}"

    def _parent(self) -> None:
        if self.share is None:
            return
        self._remember_cursor()
        if self.path:
            self.path = ntpath.dirname(self.path)
        else:
            self.share = None
        self.selected = self.top = 0
        self.refresh()
        self._restore_cursor()

    def _open_selected(self) -> None:
        if not self.entries:
            return
        entry = self.entries[self.selected]
        if entry.is_parent:
            self._parent()
            return
        if entry.is_share:
            old_share = self.share
            old_path = self.path
            old_all_entries = self.all_entries
            old_entries = self.entries
            old_selected = self.selected
            old_top = self.top
            self._remember_cursor()
            self.share = entry.name
            self.path = ""
            self.selected = self.top = 0
            self.refresh()
            if not self.entries and self.status.startswith("Error:"):
                self.share = old_share
                self.path = old_path
                self.all_entries = old_all_entries
                self.entries = old_entries
                self.selected = old_selected
                self.top = old_top
            else:
                self._restore_cursor()
            return

        assert self.share is not None
        destination = ntpath.join(self.path, entry.name) if self.path else entry.name
        if entry.is_directory:
            old_path = self.path
            old_all_entries = self.all_entries
            old_entries = self.entries
            old_selected = self.selected
            old_top = self.top
            self._remember_cursor()
            self.path = destination
            self.selected = self.top = 0
            self.refresh()
            if not self.entries and self.status.startswith("Error:"):
                self.path = old_path
                self.all_entries = old_all_entries
                self.entries = old_entries
                self.selected = old_selected
                self.top = old_top
            else:
                self._restore_cursor()
            return

        view_path = self.client.unc_path(self.share, destination)
        if (
            entry.size is not None
            and entry.size > DISPLAY_CONFIRM_THRESHOLD
            and not self._confirm_large_display(view_path, entry.size)
        ):
            self.status = "Display cancelled; file was not read"
            return

        self.status = f"Reading {view_path}..."
        self.draw()
        try:
            self.view_content, self.view_size = self.client.read_file(
                self.share, destination
            )
            self.view_path = view_path
            self.view_top = 0
            self.view_kind = "File"
            self._clear_grep()
            self.view_share = self.share
            self.view_remote_path = destination
            self.view_status = self._auto_loot_preview(self.share, destination)
            self.tree_files = []
            self.tree_errors = []
            self.tree_selected = 0
            self.status = f"Read {view_path}"
        except SmbError as exc:
            self.status = f"Error: {exc}"

    def _download(self, share: str, remote_path: str) -> tuple[Path, int]:
        return self.client.download_file(
            share,
            remote_path,
            self.loot_dir / self.client.server,
        )

    def _auto_loot_preview(self, share: str, remote_path: str) -> str:
        if not self.auto_loot_preview:
            return ""
        try:
            destination, size = self._download(share, remote_path)
        except SmbError as exc:
            return f"Auto-loot error: {exc}"
        return f"Auto-looted {size} bytes to {destination}"

    def _download_entry(self, entry: RemoteEntry) -> None:
        if self.share is None:
            self.status = "Open a share before downloading a file"
            return
        if entry.is_directory or entry.is_share or entry.is_parent:
            self.status = f"Not a file: {entry.name}"
            return

        remote_path = ntpath.join(self.path, entry.name) if self.path else entry.name
        self.status = f"Downloading {entry.name}..."
        self.draw()
        try:
            destination, size = self._download(self.share, remote_path)
            self.status = f"Saved {size} bytes to {destination}"
        except SmbError as exc:
            self.status = f"Error: {exc}"

    def _download_selected(self) -> None:
        if not self.entries:
            self.status = "No file selected"
            return
        self._download_entry(self.entries[self.selected])

    def _set_delete_status(self, message: str) -> None:
        if self.view_path is None:
            self.status = message
        else:
            self.view_status = message

    def _delete_remote_file(self, share: str, remote_path: str) -> bool:
        remote_display = self.client.unc_path(share, remote_path)
        if not self._confirm_delete(remote_display):
            self._set_delete_status("Deletion cancelled; remote file was not changed")
            return False
        try:
            self.client.delete_file(share, remote_path)
        except SmbError as exc:
            self._set_delete_status(f"Error: {exc}")
            return False
        self._remove_cached_entry(share, remote_path)
        return True

    def _remove_entry(self, entry: RemoteEntry) -> None:
        if self.share is None:
            self._set_delete_status("Open a share before deleting a file")
            return
        if entry.is_directory or entry.is_share or entry.is_parent:
            self._set_delete_status(f"Not a file: {entry.name}")
            return

        remote_path = ntpath.join(self.path, entry.name) if self.path else entry.name
        if not self._delete_remote_file(self.share, remote_path):
            return

        deleting_open_file = (
            self.view_share == self.share
            and self.view_remote_path is not None
            and ntpath.normcase(self.view_remote_path) == ntpath.normcase(remote_path)
        )
        if deleting_open_file:
            self._close_viewer()
        self.refresh(force=True)
        self._set_delete_status(
            f"Deleted {self.client.unc_path(self.share, remote_path)}"
        )

    def _remove_selected(self) -> None:
        if not self.entries:
            self.status = "No file selected"
            return
        self._remove_entry(self.entries[self.selected])

    def _remove_named_file(self, filename: str) -> None:
        matches = [
            entry
            for entry in self.entries
            if not entry.is_parent and entry.name == filename
        ]
        if not matches:
            folded = filename.casefold()
            matches = [
                entry
                for entry in self.entries
                if not entry.is_parent and entry.name.casefold() == folded
            ]
        if not matches:
            self._set_delete_status(f"File not found in this listing: {filename}")
            return
        self._remove_entry(matches[0])

    def _create_named_directory(self, directory: str) -> None:
        if self.share is None:
            self._set_operation_status("Open a share before creating a directory")
            return

        remote_path = ntpath.join(self.path, directory) if self.path else directory
        try:
            self.client.create_directory(self.share, remote_path)
        except SmbError as exc:
            self._set_operation_status(f"Error: {exc}")
            return

        self._discard_cached_subtree(self.share, remote_path)
        self._upsert_cached_entry(
            self.share,
            self.path,
            RemoteEntry(directory, True),
        )
        self.refresh(force=True)
        self._set_operation_status(
            f"Created {self.client.unc_path(self.share, remote_path)}"
        )

    def _remove_named_directory(self, directory: str) -> None:
        matches = [
            entry
            for entry in self.entries
            if not entry.is_parent and entry.name == directory
        ]
        if not matches:
            folded = directory.casefold()
            matches = [
                entry
                for entry in self.entries
                if not entry.is_parent and entry.name.casefold() == folded
            ]
        if not matches:
            self._set_delete_status(f"Directory not found in this listing: {directory}")
            return

        entry = matches[0]
        if not entry.is_directory or entry.is_share:
            self._set_delete_status(f"Not a directory: {entry.name}")
            return
        if self.share is None:
            self._set_delete_status("Open a share before removing a directory")
            return

        remote_path = ntpath.join(self.path, entry.name) if self.path else entry.name
        remote_display = self.client.unc_path(self.share, remote_path)
        if not self._confirm_delete_directory(remote_display):
            self._set_delete_status(
                "Deletion cancelled; remote directory was not changed"
            )
            return
        try:
            self.client.delete_directory(self.share, remote_path)
        except SmbError as exc:
            self._set_delete_status(f"Error: {exc}")
            return

        self._remove_cached_entry(self.share, remote_path)
        self._discard_cached_subtree(self.share, remote_path)
        self.refresh(force=True)
        self._set_delete_status(f"Deleted {remote_display}")

    def _remove_selected_directory(self) -> None:
        if not self.entries:
            self.status = "No directory selected"
            return

        entry = self.entries[self.selected]
        if not entry.is_directory or entry.is_share or entry.is_parent:
            self.status = f"Not a directory: {entry.name}"
            return
        self._remove_named_directory(entry.name)

    def _upload(self, local_argument: str) -> tuple[str, int]:
        if self.share is None:
            raise SmbError("open a share before uploading a file")
        if not local_argument:
            raise SmbError("usage: /put <local-path> or /upload <local-path>")

        local_path = Path(local_argument).expanduser()
        try:
            is_file = local_path.is_file()
        except OSError as exc:
            raise SmbError(f"could not inspect local path {local_path}: {exc}") from exc
        if not is_file:
            raise SmbError(f"local file not found: {local_path}")

        remote_path = (
            ntpath.join(self.path, local_path.name) if self.path else local_path.name
        )
        existing = [
            entry
            for entry in self.client.list_directory(self.share, self.path)
            if entry.name.casefold() == local_path.name.casefold()
        ]
        if existing and existing[0].is_directory:
            raise SmbError(
                f"a remote directory already has this name: {local_path.name}"
            )
        if existing:
            remote_display = self.client.unc_path(self.share, remote_path)
            if not self._confirm_overwrite(remote_display):
                raise UploadCancelled("upload cancelled; remote file was not changed")

        size = self.client.upload_file(self.share, remote_path, local_path)
        self._upsert_cached_entry(
            self.share,
            self.path,
            RemoteEntry(
                local_path.name,
                False,
                detail=SmbClient._format_size(size),
                size=size,
            ),
        )
        return self.client.unc_path(self.share, remote_path), size

    def _set_operation_status(self, message: str) -> None:
        if self.view_path is None:
            self.status = message
        else:
            self.view_status = message
        self.draw()

    def _scan_tree(self) -> tuple[list[TreeFile], list[str]]:
        if self.share is None:
            raise SmbError("open a share before using a tree command")

        def progress(directory: str, file_count: int) -> None:
            location = self.client.unc_path(self.share, directory)
            self._set_operation_status(f"Scanning {location} ({file_count} files)...")

        return self.client.walk_files(
            self.share,
            self.path,
            progress,
            workers=self.tree_workers,
        )

    def _relative_tree_path(self, remote_path: str) -> str:
        if not self.path:
            return remote_path
        try:
            return ntpath.relpath(remote_path, self.path)
        except ValueError:
            return remote_path

    def _select_tree_file(self, index: int) -> None:
        if not self.tree_files:
            self.tree_selected = 0
            self.view_remote_path = None
            return

        self.tree_selected = max(0, min(index, len(self.tree_files) - 1))
        selected = self.tree_files[self.tree_selected]
        self.view_remote_path = selected.path
        error_status = f"; {len(self.tree_errors)} errors" if self.tree_errors else ""
        self.view_status = (
            f"{self.tree_selected + 1}/{len(self.tree_files)} selected: "
            f"{self._relative_tree_path(selected.path)}{error_status}"
        )

    def _move_tree_selection(self, offset: int) -> None:
        self._select_tree_file(self.tree_selected + offset)

    def _open_tree_selected(self) -> None:
        if not self.tree_files or self.view_share is None:
            self.view_status = "No file selected"
            return

        selected = self.tree_files[self.tree_selected]
        view_path = self.client.unc_path(self.view_share, selected.path)
        if (
            selected.size > DISPLAY_CONFIRM_THRESHOLD
            and not self._confirm_large_display(view_path, selected.size)
        ):
            self.view_status = "Display cancelled; file was not read"
            return

        self.view_status = f"Reading {view_path}..."
        self.draw()
        try:
            self.view_content, self.view_size = self.client.read_file(
                self.view_share,
                selected.path,
            )
            self.view_path = view_path
            self.view_top = 0
            self.view_kind = "File"
            self._clear_grep()
            self.view_remote_path = selected.path
            self.view_status = self._auto_loot_preview(
                self.view_share,
                selected.path,
            )
            self.tree_files = []
            self.tree_errors = []
            self.tree_selected = 0
        except SmbError as exc:
            self.view_status = f"Error: {exc}"

    def _download_tree_selected(self) -> None:
        if not self.tree_files or self.view_share is None:
            self.view_status = "No file selected"
            return

        selected = self.tree_files[self.tree_selected]
        self.view_status = f"Downloading {selected.path}..."
        self.draw()
        try:
            destination, size = self._download(self.view_share, selected.path)
            self.view_status = f"Saved {size} bytes to {destination}"
        except SmbError as exc:
            self.view_status = f"Error: {exc}"

    def _remove_tree_selected(self) -> None:
        if not self.tree_files or self.view_share is None:
            self.view_status = "No file selected"
            return

        selected = self.tree_files[self.tree_selected]
        if not self._delete_remote_file(self.view_share, selected.path):
            return

        del self.tree_files[self.tree_selected]
        self.view_size = max(0, self.view_size - selected.size)
        if self.tree_files:
            self._select_tree_file(self.tree_selected)
            self.view_status = (
                f"Deleted {selected.path}; {len(self.tree_files)} files remain"
            )
        else:
            self.tree_selected = 0
            self.view_remote_path = None
            self.view_status = f"Deleted {selected.path}; no files remain"

    def _remove_open_file(self) -> None:
        if self.view_share is None or self.view_remote_path is None:
            self.view_status = "No remote file is open"
            return

        share = self.view_share
        remote_path = self.view_remote_path
        if not self._delete_remote_file(share, remote_path):
            return

        remote_display = self.client.unc_path(share, remote_path)
        self._close_viewer()
        self.refresh(force=True)
        self.status = f"Deleted {remote_display}"

    def _show_tree_report(
        self,
        files: list[TreeFile],
        errors: list[str],
    ) -> None:
        total_size = sum(item.size for item in files)

        self.view_kind = "Tree"
        self.view_path = self.location
        self.view_content = ""
        self.view_size = total_size
        self.view_top = 0
        self.view_share = self.share
        self.view_remote_path = files[0].path if files else None
        self.tree_files = files
        self.tree_errors = errors
        self.tree_selected = 0
        if files:
            self._select_tree_file(0)
        else:
            self.view_status = f"0 files; {len(errors)} errors" if errors else "0 files"

    def _show_tree_download_report(
        self,
        downloaded: list[tuple[TreeFile, Path, int]],
        errors: list[str],
    ) -> None:
        total_size = sum(size for _, _, size in downloaded)
        lines = [
            (
                f"Downloaded {len(downloaded)} files "
                f"({SmbClient._format_size(total_size)})"
            ),
            f"Loot directory: {self.loot_dir}",
            "",
        ]
        lines.extend(
            f"{self._relative_tree_path(item.path)} -> {destination}"
            for item, destination, _ in downloaded
        )
        if not downloaded:
            lines.append("(no files downloaded)")
        if errors:
            lines.extend(["", f"Errors ({len(errors)}):", *errors])

        self.view_kind = "Tree download"
        self.view_path = self.location
        self.view_content = "\n".join(lines)
        self.view_size = total_size
        self.view_top = 0
        self.view_share = None
        self.view_remote_path = None
        self.tree_files = []
        self.tree_errors = []
        self.tree_selected = 0
        self.view_status = (
            f"{len(downloaded)} downloaded; {len(errors)} errors"
            if errors
            else f"{len(downloaded)} downloaded"
        )

    def _run_tree_command(self, download: bool) -> None:
        try:
            files, errors = self._scan_tree()
        except SmbError as exc:
            self._set_operation_status(f"Error: {exc}")
            return

        if not download:
            self._show_tree_report(files, errors)
            return

        assert self.share is not None
        self._set_operation_status(
            f"Downloading {len(files)} files with {self.tree_workers} workers..."
        )

        def progress(completed: int, total: int, path: str) -> None:
            suffix = f": {path}" if path else ""
            self._set_operation_status(f"Downloading {completed}/{total}{suffix}")

        downloaded, download_errors = self.client.download_files_parallel(
            self.share,
            files,
            self.loot_dir / self.client.server,
            progress,
            workers=self.tree_workers,
        )
        download_errors = [*errors, *download_errors]

        self._show_tree_download_report(downloaded, download_errors)

    def _confirm_overwrite(self, remote_path: str) -> bool:
        return self._confirm_popup(
            "Remote file already exists:",
            remote_path,
            "Overwrite? [Y]/[N]",
        )

    def _confirm_large_display(self, remote_path: str, size: int) -> bool:
        return self._confirm_popup(
            f"Large file ({SmbClient._format_size(size)}):",
            remote_path,
            "Display in terminal? [Y]/[N]",
        )

    def _confirm_delete(self, remote_path: str) -> bool:
        return self._confirm_popup(
            "Delete remote file?",
            remote_path,
            "Confirm deletion? [Y]/[N]",
        )

    def _confirm_delete_directory(self, remote_path: str) -> bool:
        return self._confirm_popup(
            "Delete remote directory?",
            remote_path,
            "Confirm deletion? [Y]/[N]",
        )

    def _confirm_popup(
        self,
        heading: str,
        target: str,
        question: str,
    ) -> bool:
        while True:
            self.draw()
            height, width = self.screen.getmaxyx()
            content_width = max(1, min(72, width - 6))
            path_lines = textwrap.wrap(
                target,
                width=content_width,
                break_long_words=True,
                break_on_hyphens=False,
            ) or [target]
            lines = [
                heading,
                *path_lines,
                "",
                question,
            ]
            box_width = min(
                max(len(line) for line in lines) + 4,
                max(10, width - 2),
            )
            box_height = len(lines) + 2
            top = max(0, (height - box_height) // 2)
            left = max(0, (width - box_width) // 2)
            border = "+" + "-" * max(0, box_width - 2) + "+"

            self._safe_addstr(top, left, border, curses.A_REVERSE)
            for index, line in enumerate(lines, 1):
                body = f"| {line:<{max(0, box_width - 4)}} |"
                self._safe_addstr(top + index, left, body, curses.A_REVERSE)
            self._safe_addstr(
                top + box_height - 1,
                left,
                border,
                curses.A_REVERSE,
            )
            self.screen.refresh()

            try:
                key = self.screen.get_wch()
            except curses.error:
                continue
            if isinstance(key, str) and key.casefold() == "y":
                return True
            if key in (
                "n",
                "N",
                "\n",
                "\r",
                "\x1b",
                27,
                curses.KEY_ENTER,
            ):
                return False

    def _run_browser_command(self) -> None:
        filenames = [
            entry.name
            for entry in self.entries
            if not entry.is_directory and not entry.is_share and not entry.is_parent
        ]
        directories = [
            entry.name
            for entry in self.entries
            if entry.is_directory and not entry.is_share and not entry.is_parent
        ]
        command = self._prompt_command(filenames, directories)
        if command is None:
            self.status = "Command cancelled"
            return

        exit_argument = self._exit_argument(command)
        if exit_argument is not None:
            if exit_argument:
                self.status = "Usage: /exit or /quit"
            else:
                self.exit_requested = True
            return

        help_argument = self._help_argument(command)
        if help_argument is not None:
            if help_argument:
                self.status = "Usage: /help"
            else:
                self._show_help()
            return

        refresh_argument = self._refresh_argument(command)
        if refresh_argument is not None:
            if refresh_argument:
                self.status = "Usage: /refresh"
            else:
                self.refresh(force=True)
            return

        mode_argument = self._mode_argument(command)
        if mode_argument is not None:
            if mode_argument.upper() not in MODES:
                self.status = "Usage: /mode LIVE|OPSEC"
            else:
                self._set_mode(mode_argument)
            return

        rm_argument = self._rm_argument(command)
        if rm_argument is not None:
            if rm_argument:
                self._remove_named_file(rm_argument)
            else:
                self._remove_selected()
            return

        mkdir_argument = self._mkdir_argument(command)
        if mkdir_argument is not None:
            if not mkdir_argument:
                self.status = "Usage: /mkdir <directory>"
            else:
                self._create_named_directory(mkdir_argument)
            return

        rmdir_argument = self._rmdir_argument(command)
        if rmdir_argument is not None:
            if rmdir_argument:
                self._remove_named_directory(rmdir_argument)
            else:
                self._remove_selected_directory()
            return

        filter_argument = self._filter_argument(command)
        if filter_argument is not None:
            self._set_filter(filter_argument)
            return

        tree_download_argument = self._tree_download_argument(command)
        if tree_download_argument is not None:
            if tree_download_argument:
                self.status = "Usage: /tree_download"
            else:
                self._run_tree_command(download=True)
            return

        tree_argument = self._tree_argument(command)
        if tree_argument is not None:
            if tree_argument:
                self.status = "Usage: /tree"
            else:
                self._run_tree_command(download=False)
            return

        put_argument = self._put_argument(command)
        if put_argument is not None:
            self.status = f"Uploading {put_argument or 'file'}..."
            self.draw()
            try:
                remote_path, size = self._upload(put_argument)
                self.refresh(force=True)
                self.status = f"Uploaded {size} bytes to {remote_path}"
            except UploadCancelled as exc:
                self.status = str(exc)
            except SmbError as exc:
                self.status = f"Error: {exc}"
            return

        argument = self._get_argument(command)
        if argument is None:
            self.status = "Unknown command; use /help to list available commands"
            return
        if self.share is None:
            self.status = "Open a share before downloading a file"
            return

        if argument:
            matches = [
                entry
                for entry in self.entries
                if not entry.is_parent and entry.name == argument
            ]
            if not matches:
                folded = argument.casefold()
                matches = [
                    entry
                    for entry in self.entries
                    if not entry.is_parent and entry.name.casefold() == folded
                ]
            if not matches:
                self.status = f"File not found in this listing: {argument}"
                return
            entry = matches[0]
        elif self.entries:
            entry = self.entries[self.selected]
        else:
            self.status = "No file selected"
            return

        self._download_entry(entry)

    def _run_viewer_command(self) -> None:
        filenames = [
            entry.name
            for entry in self.entries
            if not entry.is_directory and not entry.is_share and not entry.is_parent
        ]
        directories = [
            entry.name
            for entry in self.entries
            if entry.is_directory and not entry.is_share and not entry.is_parent
        ]
        command = self._prompt_command(filenames, directories)
        if command is None:
            self.view_status = "Command cancelled"
            return

        exit_argument = self._exit_argument(command)
        if exit_argument is not None:
            if exit_argument:
                self.view_status = "Usage: /exit or /quit"
            else:
                self.exit_requested = True
            return

        help_argument = self._help_argument(command)
        if help_argument is not None:
            if help_argument:
                self.view_status = "Usage: /help"
            else:
                self._show_help()
            return

        mode_argument = self._mode_argument(command)
        if mode_argument is not None:
            if mode_argument.upper() not in MODES:
                self.view_status = "Usage: /mode LIVE|OPSEC"
            else:
                self._set_mode(mode_argument)
            return

        grep_argument = self._grep_argument(command)
        if grep_argument is not None:
            self._set_grep(grep_argument)
            return

        rm_argument = self._rm_argument(command)
        if rm_argument is not None:
            if rm_argument:
                self._remove_named_file(rm_argument)
            elif self.view_kind == "Tree":
                self._remove_tree_selected()
            elif self.view_kind == "File":
                self._remove_open_file()
            else:
                self.view_status = "No file selected"
            return

        mkdir_argument = self._mkdir_argument(command)
        if mkdir_argument is not None:
            if not mkdir_argument:
                self.view_status = "Usage: /mkdir <directory>"
            else:
                self._create_named_directory(mkdir_argument)
            return

        rmdir_argument = self._rmdir_argument(command)
        if rmdir_argument is not None:
            if rmdir_argument:
                self._remove_named_directory(rmdir_argument)
            else:
                self.view_status = "No directory selected"
            return

        tree_download_argument = self._tree_download_argument(command)
        if tree_download_argument is not None:
            if tree_download_argument:
                self.view_status = "Usage: /tree_download"
            else:
                self._run_tree_command(download=True)
            return

        tree_argument = self._tree_argument(command)
        if tree_argument is not None:
            if tree_argument:
                self.view_status = "Usage: /tree"
            else:
                self._run_tree_command(download=False)
            return

        put_argument = self._put_argument(command)
        if put_argument is not None:
            self.view_status = f"Uploading {put_argument or 'file'}..."
            self.draw()
            try:
                remote_path, size = self._upload(put_argument)
                self.refresh(force=True)
                self.view_status = f"Uploaded {size} bytes to {remote_path}"
            except UploadCancelled as exc:
                self.view_status = str(exc)
            except SmbError as exc:
                self.view_status = f"Error: {exc}"
            return

        argument = self._get_argument(command)
        if argument is None or argument:
            self.view_status = "Unknown command; use /help"
            return
        if self.view_share is None or self.view_remote_path is None:
            self.view_status = "No remote file is open"
            return

        self.view_status = "Downloading..."
        self.draw()
        try:
            destination, size = self._download(self.view_share, self.view_remote_path)
            self.view_status = f"Saved {size} bytes to {destination}"
        except SmbError as exc:
            self.view_status = f"Error: {exc}"

    def run(self) -> None:
        self._initialise_colors()
        try:
            curses.curs_set(0)
        except curses.error:
            pass
        self.screen.keypad(True)
        self.refresh()
        running = True
        while running:
            self.draw()
            key = self.screen.getch()
            if self.view_path is None:
                running = self._browser_key(key)
            else:
                self._viewer_key(key)
            if self.exit_requested:
                running = False