commandertui 1.2.0__tar.gz → 1.3.1__tar.gz

{commandertui-1.2.0 → commandertui-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: commandertui
-Version: 1.2.0
+Version: 1.3.1
 Summary: Dual-pane retro terminal file manager: compare, sync, copy and move folders
 Author: Humberto Barchini
 License-Expression: MIT
@@ -22,7 +22,7 @@ Dual-pane terminal file manager: compare two folders, sync them, or move
 files/folders between them (and to USB/SMB/any mounted path) — with a
 phosphor-green 80s-terminal look and a short modem-style boot animation.
 
-Status: **v1.2.0** — 108/108 tests passing. MIT licensed.
+Status: **v1.3.1** — 127/127 tests passing. MIT licensed.
 
 ---
 
@@ -32,7 +32,7 @@ A safe, simple alternative to heavier dual-pane file managers. It was
 written after an earlier attempt of the same idea had to be scrapped for
 running an unauthenticated local HTTP server. This project deliberately:
 
-- **Never opens a network port.** Pure terminal UI (Textual), no HTTP server (the only outgoing request is the daily update check, which you can turn off),
+- **Never opens a network port.** Pure terminal UI (Textual), no HTTP server (the only outgoing request is the update check on startup, which you can turn off),
   no webview.
 - **Never does a raw `rm -rf`.** Deletes always go through the desktop trash
   (`send2trash` → `gio trash` → manual move into `~/.local/share/Trash`, in
@@ -127,17 +127,19 @@ o.window("^commandertui$", { float = true, center = true, size = { 1174, 637 } }
 | `Backspace` | Go to parent directory |
 | `Space` | Mark/unmark item under cursor |
 | `F2` | Rename the item under the cursor (never overwrites an existing name) |
+| `F4` | Edit the file under the cursor with `$VISUAL` / `$EDITOR` (falls back to nano, vim or vi); CommanderTUI pauses and comes back when you close the editor |
 | `F5` | Copy marked (or item under cursor) to the other pane |
 | `F6` | Move marked to the other pane |
 | `F7` | Create a folder in the active pane |
 | `F8` / `Delete` | Delete marked (to trash) |
 | `/` | Filter the active pane by name (contains, ignores case) as you type; `Enter` keeps it, `Esc` clears it |
 | `+` / `-` / `*` | Mark / unmark by pattern (`*.iso`, or plain text = contains) / invert marks, over the rows shown |
-| `u` | Update: shows the pending new version (see *Updates*) |
+| `u` | Check for updates now (also the **Updates** button): asks PyPI right away and offers the new version if there is one |
 | `i` | Size: file/folder count and total bytes of marked items (background, `Esc` stops it) |
 | `h` | Show/hide hidden (dot) files in both panes |
+| `t` | Color theme: Phosphor green (default), Phosphor amber, Nord, Gruvbox, Dracula, Tokyo Night, Catppuccin Mocha, Solarized Dark, Monokai, Textual Dark. Previews as you move, Enter keeps it (saved in `~/.config/commandertui/settings.json`), Esc goes back |
 | `p` | Places: jump to a mounted drive (USB/SMB/rclone), saved bookmark or saved network location. Inside: `a` add a network location, `s` save the active pane's folder as a bookmark, `d` delete a saved one |
-| `c` | Compare: full recursive diff between the two panes' current folders |
+| `c` | Compare: full recursive diff between the two panes' current folders, with size and date of both sides (and which is newer when a file changed) |
 | `r` | Refresh both panes |
 | `q` | Quit |
 
@@ -160,13 +162,14 @@ when picked. If the server asks for a login, `gio` asks for it in the
 terminal and can remember it in the system keyring, exactly like Nautilus.
 
 Every key also has a clickable box on the bottom bar: one row on wide windows
-(168+ columns), two rows when narrower (110 columns is the practical minimum).
+(168+ columns), two rows when narrower (120 columns is the practical minimum).
 The active pane has the thick border and the inverted path bar; each path bar
 shows the free space of that disk, and the marked count and total size.
 
 ## Updates
 
-Once a day, in the background and only after the start-up animation, the app
+On every launch, in the background while the start-up animation plays (its
+CHECKING UPDATES line shows the result), the app
 asks PyPI for the latest version (a plain GET, nothing about you is sent). If
 a newer one exists you get a dialog -- **Update now / Later / Skip this
 version** -- and the header keeps saying `update X available (press u)`.
@@ -213,7 +216,8 @@ commandertui/
 ├── executor.py             # runs an OperationQueue against the filesystem
 ├── bookmarks.py             # detected mounts (USB/SMB/rclone) + saved places
 ├── netlocations.py           # SMB/SFTP/FTP locations via gio (list shares, mount, save)
-├── theme.py                  # green/amber phosphor palettes
+├── theme.py                  # phosphor green/amber themes + the stylesheet (Textual theme variables)
+├── settings.py               # saved settings (color theme)
 ├── boot.py                    # startup "modem" reveal animation
 ├── widgets.py                  # FilePanel: one pane's directory listing
 ├── modals.py                    # Confirm / Places / Input / Size / Message screens

{commandertui-1.2.0 → commandertui-1.3.1}/README.md

@@ -4,7 +4,7 @@ Dual-pane terminal file manager: compare two folders, sync them, or move
 files/folders between them (and to USB/SMB/any mounted path) — with a
 phosphor-green 80s-terminal look and a short modem-style boot animation.
 
-Status: **v1.2.0** — 108/108 tests passing. MIT licensed.
+Status: **v1.3.1** — 127/127 tests passing. MIT licensed.
 
 ---
 
@@ -14,7 +14,7 @@ A safe, simple alternative to heavier dual-pane file managers. It was
 written after an earlier attempt of the same idea had to be scrapped for
 running an unauthenticated local HTTP server. This project deliberately:
 
-- **Never opens a network port.** Pure terminal UI (Textual), no HTTP server (the only outgoing request is the daily update check, which you can turn off),
+- **Never opens a network port.** Pure terminal UI (Textual), no HTTP server (the only outgoing request is the update check on startup, which you can turn off),
   no webview.
 - **Never does a raw `rm -rf`.** Deletes always go through the desktop trash
   (`send2trash` → `gio trash` → manual move into `~/.local/share/Trash`, in
@@ -109,17 +109,19 @@ o.window("^commandertui$", { float = true, center = true, size = { 1174, 637 } }
 | `Backspace` | Go to parent directory |
 | `Space` | Mark/unmark item under cursor |
 | `F2` | Rename the item under the cursor (never overwrites an existing name) |
+| `F4` | Edit the file under the cursor with `$VISUAL` / `$EDITOR` (falls back to nano, vim or vi); CommanderTUI pauses and comes back when you close the editor |
 | `F5` | Copy marked (or item under cursor) to the other pane |
 | `F6` | Move marked to the other pane |
 | `F7` | Create a folder in the active pane |
 | `F8` / `Delete` | Delete marked (to trash) |
 | `/` | Filter the active pane by name (contains, ignores case) as you type; `Enter` keeps it, `Esc` clears it |
 | `+` / `-` / `*` | Mark / unmark by pattern (`*.iso`, or plain text = contains) / invert marks, over the rows shown |
-| `u` | Update: shows the pending new version (see *Updates*) |
+| `u` | Check for updates now (also the **Updates** button): asks PyPI right away and offers the new version if there is one |
 | `i` | Size: file/folder count and total bytes of marked items (background, `Esc` stops it) |
 | `h` | Show/hide hidden (dot) files in both panes |
+| `t` | Color theme: Phosphor green (default), Phosphor amber, Nord, Gruvbox, Dracula, Tokyo Night, Catppuccin Mocha, Solarized Dark, Monokai, Textual Dark. Previews as you move, Enter keeps it (saved in `~/.config/commandertui/settings.json`), Esc goes back |
 | `p` | Places: jump to a mounted drive (USB/SMB/rclone), saved bookmark or saved network location. Inside: `a` add a network location, `s` save the active pane's folder as a bookmark, `d` delete a saved one |
-| `c` | Compare: full recursive diff between the two panes' current folders |
+| `c` | Compare: full recursive diff between the two panes' current folders, with size and date of both sides (and which is newer when a file changed) |
 | `r` | Refresh both panes |
 | `q` | Quit |
 
@@ -142,13 +144,14 @@ when picked. If the server asks for a login, `gio` asks for it in the
 terminal and can remember it in the system keyring, exactly like Nautilus.
 
 Every key also has a clickable box on the bottom bar: one row on wide windows
-(168+ columns), two rows when narrower (110 columns is the practical minimum).
+(168+ columns), two rows when narrower (120 columns is the practical minimum).
 The active pane has the thick border and the inverted path bar; each path bar
 shows the free space of that disk, and the marked count and total size.
 
 ## Updates
 
-Once a day, in the background and only after the start-up animation, the app
+On every launch, in the background while the start-up animation plays (its
+CHECKING UPDATES line shows the result), the app
 asks PyPI for the latest version (a plain GET, nothing about you is sent). If
 a newer one exists you get a dialog -- **Update now / Later / Skip this
 version** -- and the header keeps saying `update X available (press u)`.
@@ -195,7 +198,8 @@ commandertui/
 ├── executor.py             # runs an OperationQueue against the filesystem
 ├── bookmarks.py             # detected mounts (USB/SMB/rclone) + saved places
 ├── netlocations.py           # SMB/SFTP/FTP locations via gio (list shares, mount, save)
-├── theme.py                  # green/amber phosphor palettes
+├── theme.py                  # phosphor green/amber themes + the stylesheet (Textual theme variables)
+├── settings.py               # saved settings (color theme)
 ├── boot.py                    # startup "modem" reveal animation
 ├── widgets.py                  # FilePanel: one pane's directory listing
 ├── modals.py                    # Confirm / Places / Input / Size / Message screens

commandertui-1.3.1/commandertui/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.3.1"

{commandertui-1.2.0 → commandertui-1.3.1}/commandertui/app.py

@@ -4,10 +4,9 @@ import os
 
 from textual.app import App
 
-from . import updater
+from . import settings, theme, updater
 from .boot import BootScreen
 from .main_screen import MainScreen
-from .theme import css_for
 
 
 class CommanderApp(App):
@@ -15,32 +14,50 @@ class CommanderApp(App):
     see its docstring for why that split matters for key bindings.
     """
 
-    CSS = css_for("green")
+    CSS = theme.CSS
 
     def __init__(
         self, left_path: str | None = None, right_path: str | None = None, check_updates: bool = True
     ) -> None:
         super().__init__()
+        for phosphor in theme.PHOSPHOR_THEMES:
+            self.register_theme(phosphor)
+        saved = settings.load_theme()
+        self.theme = saved if saved in self.available_themes else theme.DEFAULT_THEME
         self.check_updates = check_updates and not updater.updates_disabled()
         self.update_info: updater.UpdateInfo | None = None
+        # What the boot screen's CHECKING UPDATES line shows.
+        self.update_state = "pending" if self.check_updates else "off"
+        self.update_latest = ""
         self.update_prompted = False
         self.left_path = os.path.abspath(left_path or os.path.expanduser("~"))
         self.right_path = os.path.abspath(right_path or os.path.expanduser("~"))
 
+    def on_unmount(self) -> None:
+        # Whatever theme is showing when the app closes is the one to reopen
+        # with -- covers the picker (t) and Textual's own palette (ctrl+p).
+        settings.save_theme(self.theme)
+
+    def preview_theme(self, name: str) -> None:
+        self.theme = name
+
     def on_mount(self) -> None:
         self.push_screen(MainScreen(self.left_path, self.right_path))
-        self.push_screen(BootScreen(), self._after_boot)
-
-    def _after_boot(self, _result=None) -> None:
-        # Looked up only once the boot animation is over, so a quick answer
-        # can never pop a dialog over it.
+        self.push_screen(BootScreen())
+        # Looked up while the boot animation plays (it shows the result); the
+        # dialog itself waits for the main screen, so it never covers the boot.
         if self.check_updates:
             self.run_worker(self._look_for_update, thread=True)
 
     def _look_for_update(self) -> None:
-        info = updater.check()
+        info, status = updater.check_status()
+        self.call_from_thread(self._update_checked, info, status)
+
+    def _update_checked(self, info: updater.UpdateInfo | None, status: str) -> None:
+        self.update_state = status
         if info:
-            self.call_from_thread(self.update_found, info)
+            self.update_latest = info.latest
+            self.update_found(info)
 
     def update_found(self, info: updater.UpdateInfo) -> None:
         """Remember the newer version and say so in the header; the dialog

{commandertui-1.2.0 → commandertui-1.3.1}/commandertui/ascii_font.py

@@ -17,11 +17,14 @@ _FONT: dict[str, list[str]] = {
 BLOCK = "█"  # solid block, swapped in for the '#' placeholders above
 
 
-def banner(word: str, gap: int = 1) -> str:
-    """Render `word` as 5 lines of block letters."""
+def banner(word: str, gap: int = 1, scale: int = 1) -> str:
+    """Render `word` as block letters, 5 rows tall at scale 1; a larger scale
+    makes every block `scale` cells wide and tall."""
     letters = [_FONT[ch] for ch in word.upper()]
     sep = " " * gap
     rows = []
     for row_index in range(5):
-        rows.append(sep.join(letter[row_index] for letter in letters).replace("#", BLOCK))
+        row = sep.join(letter[row_index] for letter in letters).replace("#", BLOCK)
+        row = "".join(ch * scale for ch in row)
+        rows.extend([row] * scale)
     return "\n".join(rows)

{commandertui-1.2.0 → commandertui-1.3.1}/commandertui/boot.py

@@ -8,16 +8,25 @@ from textual.widgets import Static
 from .ascii_font import banner
 
 CURSOR = "█"  # solid block, like a CRT text cursor
+SPINNER = "|/-\\"
+LINE_WIDTH = 44  # fixed, so a status changing later never moves the box
+WIDE_ENOUGH = 114  # terminal columns for the double-size title (110 wide with its box)
 
 
-def _build_art() -> str:
-    title_lines = banner("COMMANDER").split("\n")
+def _line(label: str, status: str) -> str:
+    dots = "." * (LINE_WIDTH - len(label) - len(status) - 2)
+    return f"{label} {dots} {status}"
+
+
+def _build_art(scale: int = 1, update_status: str = "OK") -> str:
+    title_lines = banner("COMMANDER", scale=scale).split("\n")
     body_lines = [
         "",
         "T U I  --  dual-pane file manager",
         "",
-        "CONNECT 2400 ...................... OK",
-        "LOADING PANELS ..................... OK",
+        _line("CONNECT 2400", "OK"),
+        _line("LOADING PANELS", "OK"),
+        _line("CHECKING UPDATES", update_status),
         "READY.",
     ]
     content = title_lines + body_lines
@@ -31,6 +40,11 @@ def _build_art() -> str:
     return "\n".join(boxed)
 
 
+def update_status_text(state: str, latest: str = "") -> str:
+    """What the CHECKING UPDATES line says for an app update state."""
+    return {"ok": "OK", "off": "OFF", "offline": "OFFLINE", "skipped": "SKIPPED"}.get(state, f"NEW {latest}")
+
+
 ART = _build_art()
 
 
@@ -63,13 +77,16 @@ class BootScreen(Screen):
 
     def __init__(
         self,
-        art: str = ART,
+        art: str | None = None,
         chars_per_tick: int = 3,
         tick_seconds: float = 0.035,
         bell: bool = True,
     ) -> None:
         super().__init__()
-        self.art = art
+        self.fixed_art = art  # tests/tools can pass a fixed picture; normally built live
+        self.art = art or ART
+        self._scale = 1
+        self._frame = 0
         self.chars_per_tick = chars_per_tick
         self.tick_seconds = tick_seconds
         self.bell = bell
@@ -87,10 +104,35 @@ class BootScreen(Screen):
         yield Static("", id="boot-hint")
 
     def on_mount(self) -> None:
+        # Double-size title when the window is wide enough for it.
+        self._scale = 2 if self.app.size.width >= WIDE_ENOUGH else 1
         self._timer = self.set_interval(self.tick_seconds, self._tick)
 
+    def _pending(self) -> bool:
+        return self.fixed_art is None and getattr(self.app, "update_state", "off") == "pending"
+
+    def _current_art(self) -> str:
+        if self.fixed_art is not None:
+            return self.fixed_art
+        state = getattr(self.app, "update_state", "off")
+        if state == "pending":
+            status = SPINNER[self._frame % 4]
+        else:
+            status = update_status_text(state, getattr(self.app, "update_latest", ""))
+        return _build_art(self._scale, status)
+
+    def _limit(self) -> int:
+        """How far the reveal may go: while the update check is still running
+        it waits just before the READY. row."""
+        if not self._pending():
+            return len(self.art)
+        ready = self.art.index("READY.")
+        return self.art.rfind("\n", 0, ready) + 1
+
     def _tick(self) -> None:
-        self._pos = min(len(self.art), self._pos + self.chars_per_tick)
+        self._frame += 1
+        self.art = self._current_art()
+        self._pos = min(self._limit(), self._pos + self.chars_per_tick)
         widget = self.query_one("#boot-text", Static)
         visible = self.art[: self._pos]
         cursor = CURSOR if self._pos < len(self.art) else ""
@@ -102,13 +144,19 @@ class BootScreen(Screen):
                 self._timer.stop()
             if self.bell:
                 self.app.bell()
-            self.query_one("#boot-hint", Static).update("[ENTER] to continue")
+            self.query_one("#boot-hint", Static).update("\\[ENTER] to continue")
 
     def action_continue_(self) -> None:
-        if not self._done:
-            # Not drawn yet: Enter fast-forwards straight to the final frame
-            # instead of doing nothing, in case someone doesn't want to wait.
-            self._pos = len(self.art)
+        if self._pos < self._limit():
+            # Not drawn yet: Enter fast-forwards as far as it can go instead
+            # of doing nothing, in case someone doesn't want to wait.
+            self._pos = self._limit()
             self._tick()
             return
+        if self._pending() and self._pos < len(self.art):
+            # Reveal is parked waiting on the update check: don't make the
+            # user wait for the network; a newer version still gets offered
+            # when it arrives.
+            self.dismiss()
+            return
         self.dismiss()

{commandertui-1.2.0 → commandertui-1.3.1}/commandertui/compare_screen.py

@@ -1,5 +1,8 @@
 from __future__ import annotations
 
+import threading
+import time
+
 from textual.app import ComposeResult
 from textual.binding import Binding
 from textual.containers import Vertical
@@ -8,10 +11,10 @@ from textual.widgets import DataTable, Static
 
 from .diff import compare
 from .modals import MessageScreen
-from .models import DiffStatus, OpKind, OpSide, OperationQueue, QueuedOp
+from .models import DiffEntry, DiffStatus, EntryKind, FileEntry, OpKind, OpSide, OperationQueue, QueuedOp
 from .plan import plan_mirror, plan_two_way, plan_update
 from .run_queue import run_queue_with_progress
-from .widgets import CompareBar
+from .widgets import SPINNER_FRAMES, CompareBar, _format_bytes
 
 STATUS_LABEL = {
     DiffStatus.LEFT_ONLY: "< only left",
@@ -21,6 +24,23 @@ STATUS_LABEL = {
 }
 
 
+def side_info(entry: FileEntry | None) -> str:
+    """"1.2 MB  2026-10-20 14:03" for one side of a difference ("-" if absent)."""
+    if entry is None:
+        return "-"
+    when = time.strftime("%Y-%m-%d %H:%M", time.localtime(entry.mtime))
+    size = "<dir>" if entry.kind == EntryKind.DIR else _format_bytes(entry.size)
+    return f"{size}  {when}"
+
+
+def status_text(d: DiffEntry) -> str:
+    """Status label; for a changed file also says which side has the newer copy."""
+    label = STATUS_LABEL[d.status]
+    if d.status == DiffStatus.MODIFIED and d.left and d.right and d.left.mtime != d.right.mtime:
+        label += " (left newer)" if d.left.mtime > d.right.mtime else " (right newer)"
+    return label
+
+
 class CompareScreen(Screen):
     """Full recursive diff between the two panes' current directories, with
     bulk actions (mirror/update/two-way) or per-item manual handling.
@@ -42,6 +62,10 @@ class CompareScreen(Screen):
         self.left_root = left_root
         self.right_root = right_root
         self.manual_marks: set[str] = set()
+        self.diffs: list[DiffEntry] = []
+        self.scanning = False
+        self._cancel = threading.Event()
+        self._spinner = None
 
     def compose(self) -> ComposeResult:
         yield Static("", id="compare-summary")
@@ -51,16 +75,63 @@ class CompareScreen(Screen):
     def on_mount(self) -> None:
         self.reload()
 
+    def _stop_spinner(self) -> None:
+        if self._spinner is not None:
+            self._spinner.stop()
+            self._spinner = None
+
     def reload(self) -> None:
-        self.diffs = compare(self.left_root, self.right_root)
+        """Compare in a worker thread (a big tree can take minutes), with a
+        spinner so the screen never looks frozen; Esc cancels."""
+        if self.scanning:
+            return
+        self.scanning = True
+        cancel = self._cancel = threading.Event()
+        summary = self.query_one("#compare-summary", Static)
+        started = time.monotonic()
+        frame = 0
+
+        def spin() -> None:
+            nonlocal frame
+            frame += 1
+            summary.update(
+                f"{self.left_root}  <->  {self.right_root}\n"
+                f"Comparing {SPINNER_FRAMES[frame % 4]}  {int(time.monotonic() - started)}s"
+                "   (Esc to cancel)"
+            )
+
+        spin()
+        self._spinner = self.set_interval(0.12, spin)
+
+        def work() -> None:
+            try:
+                diffs, error = compare(self.left_root, self.right_root, cancel_check=cancel.is_set), ""
+            except OSError as e:
+                diffs, error = [], str(e)
+            if not cancel.is_set():
+                self.app.call_from_thread(self._scan_done, diffs, error)
+
+        self.run_worker(work, thread=True)
+
+    def _scan_done(self, diffs: list[DiffEntry], error: str) -> None:
+        self._stop_spinner()
+        self.scanning = False
+        if error:
+            self.app.push_screen(MessageScreen(f"Could not compare:\n{error}"))
+        self.diffs = diffs
+        self._fill_table()
+
+    def _fill_table(self) -> None:
         table = self.query_one("#compare-table", DataTable)
         table.clear(columns=True)
-        table.add_columns(" ", "Path", "Status")
+        table.add_columns(" ", "Path", "Status", "Left (size, date)", "Right (size, date)")
         for d in self.diffs:
             if d.status == DiffStatus.IDENTICAL:
                 continue
             mark = "*" if d.rel_path in self.manual_marks else ""
-            table.add_row(mark, d.rel_path, STATUS_LABEL[d.status], key=d.rel_path)
+            table.add_row(
+                mark, d.rel_path, status_text(d), side_info(d.left), side_info(d.right), key=d.rel_path
+            )
 
         non_identical = sum(1 for d in self.diffs if d.status != DiffStatus.IDENTICAL)
         summary = self.query_one("#compare-summary", Static)
@@ -70,22 +141,35 @@ class CompareScreen(Screen):
         )
 
     def action_back(self) -> None:
+        self._cancel.set()  # stops a running comparison; its late result is dropped
+        self._stop_spinner()
         self.dismiss()
 
+    def _busy(self) -> bool:
+        if self.scanning:
+            self.notify("Still comparing. Wait for it to finish, or press Esc to cancel.", severity="warning")
+        return self.scanning
+
     def _run_queue(self, title: str, queue: OperationQueue) -> None:
         run_queue_with_progress(
             self, title, queue, self.left_root, self.right_root, after=lambda report: self.reload()
         )
 
     def action_mirror(self) -> None:
+        if self._busy():
+            return
         active = [d for d in self.diffs if d.status != DiffStatus.IDENTICAL]
         self._run_queue("Mirror: make RIGHT identical to LEFT", plan_mirror(active))
 
     def action_update(self) -> None:
+        if self._busy():
+            return
         active = [d for d in self.diffs if d.status != DiffStatus.IDENTICAL]
         self._run_queue("Update: copy new/changed LEFT -> RIGHT (no deletes)", plan_update(active))
 
     def action_two_way(self) -> None:
+        if self._busy():
+            return
         active = [d for d in self.diffs if d.status != DiffStatus.IDENTICAL]
         queue, conflicts = plan_two_way(active)
         if conflicts:
@@ -99,6 +183,8 @@ class CompareScreen(Screen):
         self._run_queue("Two-way: propagate each side's exclusive changes", queue)
 
     def action_toggle_manual(self) -> None:
+        if self._busy():
+            return
         table = self.query_one("#compare-table", DataTable)
         if table.row_count == 0:
             return
@@ -110,9 +196,11 @@ class CompareScreen(Screen):
             self.manual_marks.discard(rel_path)
         else:
             self.manual_marks.add(rel_path)
-        self.reload()
+        self._fill_table()
 
     def action_copy_manual(self) -> None:
+        if self._busy():
+            return
         if not self.manual_marks:
             self.app.push_screen(MessageScreen("No items marked. Use [space] first."))
             return

commandertui-1.3.1/commandertui/editor.py

@@ -0,0 +1,26 @@
+"""Which text editor F4 opens: the user's own choice first."""
+
+from __future__ import annotations
+
+import os
+import shlex
+import shutil
+
+FALLBACKS = ("nano", "vim", "vi")
+
+
+def editor_command() -> list[str] | None:
+    """$VISUAL, then $EDITOR, then the first of nano/vim/vi that is installed."""
+    for var in ("VISUAL", "EDITOR"):
+        value = os.environ.get(var, "").strip()
+        if value:
+            try:
+                parts = shlex.split(value)
+            except ValueError:
+                continue
+            if parts and shutil.which(parts[0]):
+                return parts
+    for name in FALLBACKS:
+        if shutil.which(name):
+            return [name]
+    return None