Refactor PathInfo, harden cancel logic, unify key dispatch, add cargo-deny

- PathInfo now stores path: PathBuf and display_name: String, supporting
  non-UTF8 filenames (lossy display) instead of silently dropping them
- Replace unreachable!() in cancel_most_recent_task with proper pop-then-match
- Unify hardcoded key dispatch: handler.rs now uses hardcoded_action() from
  keybindings.rs as single source of truth
- Eliminate intermediate Vec allocations in sort() via sort_by closures
- Add macOS ARM64 to CI build matrix (aarch64-apple-darwin)
- Quote clipboard paths with shell_words::quote for newline safety
- Switch CI from deprecated cargo-audit to EmbarkStudios/cargo-deny-action
- Convert dir_total_size from recursive to iterative (no stack overflow)

Author: andornaut

.github/workflows/release.yml

@@ -39,15 +39,24 @@ jobs:
       - name: Run tests
         run: cargo test
 
-      - name: Audit dependencies
-        run: cargo install cargo-audit && cargo audit
+      - name: Check dependencies
+        uses: EmbarkStudios/cargo-deny-action@v2
 
   build:
     needs: check
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-latest]
+        include:
+          - os: ubuntu-latest
+            target: x86_64-unknown-linux-gnu
+            artifact_name: filectrl-linux
+          - os: macos-latest
+            target: x86_64-apple-darwin
+            artifact_name: filectrl-macos
+          - os: macos-latest
+            target: aarch64-apple-darwin
+            artifact_name: filectrl-macos-arm64
 
     steps:
       - name: Checkout code
@@ -60,14 +69,17 @@ jobs:
         if: matrix.os == 'ubuntu-latest'
         run: sudo apt-get update && sudo apt-get install -y libxcb1-dev libxcb-render0-dev libxcb-shape0-dev libxcb-xfixes0-dev
 
+      - name: Add Rust target
+        run: rustup target add ${{ matrix.target }}
+
       - name: Build
-        run: cargo build --release
+        run: cargo build --release --target ${{ matrix.target }}
 
       - name: Upload build artifact
         uses: actions/upload-artifact@v7
         with:
-          name: filectrl-${{ matrix.os }}
-          path: target/release/filectrl
+          name: ${{ matrix.artifact_name }}
+          path: target/${{ matrix.target }}/release/filectrl
 
   release:
     needs: build
@@ -94,8 +106,9 @@ jobs:
       - name: Prepare release assets
         run: |
           mkdir release-assets
-          cp artifacts/filectrl-ubuntu-latest/filectrl release-assets/filectrl-linux
-          cp artifacts/filectrl-macos-latest/filectrl release-assets/filectrl-macos
+          cp artifacts/filectrl-linux/filectrl release-assets/filectrl-linux
+          cp artifacts/filectrl-macos/filectrl release-assets/filectrl-macos
+          cp artifacts/filectrl-macos-arm64/filectrl release-assets/filectrl-macos-arm64
 
       - name: Create release
         uses: softprops/action-gh-release@v3
@@ -109,3 +122,4 @@ jobs:
           files: |
             release-assets/filectrl-linux
             release-assets/filectrl-macos
+            release-assets/filectrl-macos-arm64

Cargo.lock

@@ -1,6 +1,6 @@
 # FileCTRL
 
-FileCTRL is a light, opinionated, responsive, theme-able, and simple Text User Interface (TUI) file manager for Linux and macOS
+FileCTRL is a lightweight, opinionated, responsive, theme-able, and simple Text User Interface (TUI) file manager for Linux and macOS
 
 [![42KM theme](./screenshots/42KM.png)](./screenshots/42KM.png)
 
@@ -44,7 +44,7 @@ Run `filectrl --help` to view the available command line arguments and options:
 ```text
 Usage: filectrl [-c <config>] [-i <include...>] [--write-default-config] [--write-default-themes] [--colors-256] [--keybindings] [--] [<directory>]
 
-FileCTRL is a light, opinionated, responsive, theme-able, and simple Text User Interface (TUI) file manager for Linux and macOS
+FileCTRL is a lightweight, opinionated, responsive, theme-able, and simple Text User Interface (TUI) file manager for Linux and macOS
 
 Positional Arguments:
   directory         path to a directory to navigate to
@@ -174,7 +174,7 @@ Run `filectrl --write-default-config` to write the [default configuration](./src
 You can also override only the properties you want to change:
 
 ```bash
-$ cat ~/.config/filectrl/config.toml
+cat ~/.config/filectrl/config.toml
 [openers.linux]
 open_current_directory = "alacritty --working-directory %s"
 open_new_window = "alacritty --command filectrl %s"

README.md

@@ -0,0 +1,24 @@
+# cargo-deny configuration
+# https://embarkstudios.github.io/cargo-deny/
+
+[advisories]
+ignore = []
+
+[licenses]
+allow = [
+    "Apache-2.0",
+    "BSD-2-Clause",
+    "BSD-3-Clause",
+    "ISC",
+    "MIT",
+    "OpenSSL",
+    "Unicode-3.0",
+    "Zlib",
+]
+
+[bans]
+multiple-versions = "warn"
+
+[sources]
+unknown-registry = "deny"
+unknown-git = "deny"

deny.toml

@@ -4,7 +4,7 @@ use std::{
 };
 
 use crate::file_system::path_info::PathInfo;
-use anyhow::{Error, anyhow};
+use anyhow::{Error, Result, anyhow};
 use arboard::Clipboard as ArboardClipboard;
 use log::warn;
 
@@ -96,23 +96,18 @@ impl ClipboardEntry {
     }
 }
 
-/// Serialized as `"cp /path\n/path2..."` or `"mv /path\n/path2..."` in the system clipboard.
-/// Paths are stored unquoted because they are never passed to a shell -- they are parsed back
-/// into `PathInfo` values and used directly with Rust filesystem APIs (`fs::copy`, `fs::rename`,
-/// etc.), so there is no shell injection risk.
+/// Serialized as `"cp '/path/one' '/path/two'"` in the system clipboard.
+/// Paths are quoted with `shell_words::quote` so filenames containing spaces,
+/// newlines, or other shell metacharacters round-trip correctly.
 impl Display for ClipboardEntry {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         let name = match self {
             Self::Copy(_) => "cp",
             Self::Move(_) => "mv",
         };
         write!(f, "{name}")?;
-        // First path is space-separated from the command; the rest are
-        // newline-separated. An empty path list writes just the command
-        // (which TryFrom rejects as invalid) rather than panicking.
-        for (i, path) in self.paths().iter().enumerate() {
-            let separator = if i == 0 { ' ' } else { '\n' };
-            write!(f, "{separator}{path}")?;
+        for path in self.paths() {
+            write!(f, " {}", shell_words::quote(&path.path.to_string_lossy()))?;
         }
         Ok(())
     }
@@ -122,26 +117,27 @@ impl TryFrom<&str> for ClipboardEntry {
     type Error = Error;
 
     fn try_from(value: &str) -> Result<Self, Self::Error> {
-        let mut lines = value.lines();
+        let parts =
+            shell_words::split(value).map_err(|e| anyhow!("Invalid clipboard format: {e}"))?;
 
-        let first_line = lines.next().ok_or_else(|| anyhow!("Empty clipboard"))?;
-        let mut parts = first_line.splitn(2, ' ');
-
-        let command_str = parts.next().ok_or_else(|| anyhow!("Missing command"))?;
-        let path_str = parts.next().ok_or_else(|| anyhow!("Missing path"))?;
-
-        let mut paths = vec![PathInfo::try_from(path_str)?];
-        for line in lines {
-            if !line.is_empty() {
-                paths.push(PathInfo::try_from(line)?);
-            }
+        if parts.len() < 2 {
+            return Err(anyhow!("Missing command or path in clipboard"));
         }
 
-        match command_str {
-            "cp" => Ok(Self::Copy(paths)),
-            "mv" => Ok(Self::Move(paths)),
-            _ => Err(anyhow!("Invalid ClipboardEntry: {command_str}")),
-        }
+        parse_clipboard_parts(&parts)
+    }
+}
+
+fn parse_clipboard_parts(parts: &[String]) -> Result<ClipboardEntry> {
+    let command_str = &parts[0];
+    let paths: Vec<_> = parts[1..]
+        .iter()
+        .map(|p| PathInfo::try_from(p.as_str()))
+        .collect::<Result<Vec<_>, _>>()?;
+    match command_str.as_str() {
+        "cp" => Ok(ClipboardEntry::Copy(paths)),
+        "mv" => Ok(ClipboardEntry::Move(paths)),
+        _ => Err(anyhow!("Invalid ClipboardEntry: {command_str}")),
     }
 }
 

src/app/clipboard.rs

@@ -347,6 +347,18 @@ fn hardcoded_keys(action: Action) -> &'static [KeyCombo] {
         .map_or(&[], |(_, keys)| *keys)
 }
 
+/// Look up an action from a key press using only hardcoded bindings.
+/// Returns `None` if the key combo is not hardcoded.
+pub fn hardcoded_action(code: &KeyCode, modifiers: &KeyModifiers) -> Option<Action> {
+    let combo = KeyCombo::new(*code, *modifiers);
+    for (action, keys) in HARDCODED {
+        if keys.contains(&combo) {
+            return Some(*action);
+        }
+    }
+    None
+}
+
 /// Build the key→action HashMap, detecting duplicate key mappings.
 /// Hardcoded keys are inserted first for actions present in this mode's
 /// binding list, then user bindings override them.

src/app/config/keybindings.rs

@@ -128,7 +128,7 @@ impl FileSystem {
                     self.previous_directory = Some(current.clone());
                 }
                 self.directory = Some(directory.clone());
-                let path_buf = PathBuf::from(&directory.path);
+                let path_buf = directory.path.clone();
                 if let Some(watcher) = &mut self.watcher
                     && let Err(e) = watcher.watch_directory(path_buf.clone())
                 {
@@ -165,21 +165,16 @@ impl FileSystem {
 
     fn cancel_most_recent_task(&mut self) -> CommandResult {
         // LIFO across file operations and search: cancel whichever was started most recently.
-        while let Some(cancellable) = self.cancellables.last() {
+        while let Some(cancellable) = self.cancellables.pop() {
             match cancellable {
-                Cancellable::Task((_, token, _)) => {
+                Cancellable::Task((_, token, kind)) => {
                     if !token.is_cancelled() {
                         token.cancel();
-                        let Some(Cancellable::Task((_, _, kind))) = self.cancellables.pop() else {
-                            unreachable!()
-                        };
                         return Command::AlertInfo(format!("Cancelled: {}", kind.message())).into();
                     }
-                    self.cancellables.pop();
                 }
                 Cancellable::Search(token) => {
                     token.cancel();
-                    self.cancellables.pop();
                     // Non-destructive: keep streamed results and the notice;
                     // NoticesView relabels it to "Cancelled: [Searching] <query>".
                     return Command::CancelSearch.into();

src/file_system.rs

@@ -42,7 +42,7 @@ pub(super) fn open_in(path: &PathInfo, template: &str, command_tx: Sender<Comman
     if template.is_empty() {
         return Ok(());
     }
-    let command = template.replace("%s", &shell_words::quote(&path.path));
+    let command = template.replace("%s", &shell_words::quote(&path.path.to_string_lossy()));
     let mut child = spawn_detached("sh", ["-c", &command])
         .map_err(|error| anyhow!("Failed to run command \"{command}\": {error}"))?;