Add "New folder" feature

- Add back-end feature
- Add front-end implementation
- Add conflict handling, incl. file watching
- Add FE+BE+E2E tests
- Document new feature

Author: vdavid

apps/desktop/coverage-allowlist.json

@@ -10,6 +10,7 @@
         "file-explorer/FileIcon.svelte": { "reason": "Simple UI component, display only" },
         "file-explorer/FilePane.svelte": { "reason": "Tested in integration.test.ts, complex component" },
         "file-explorer/FullList.svelte": { "reason": "Logic tested in full-list-utils.ts, component mounting heavy" },
+        "file-explorer/NewFolderDialog.svelte": { "reason": "UI modal, logic tested in new-folder-utils.test.ts" },
         "file-explorer/NetworkBrowser.svelte": { "reason": "Network component, needs Tauri integration" },
         "file-explorer/PaneResizer.svelte": { "reason": "Mouse drag UI component, difficult to unit test" },
         "file-explorer/NetworkLoginForm.svelte": { "reason": "Network component, needs Tauri integration" },

apps/desktop/src-tauri/src/commands/file_system.rs

@@ -39,6 +39,35 @@ pub fn path_exists(path: String) -> bool {
     path_buf.exists()
 }
 
+/// Creates a new directory.
+///
+/// # Arguments
+/// * `parent_path` - The parent directory path. Supports tilde expansion (~).
+/// * `name` - The folder name to create.
+///
+/// # Returns
+/// The full path of the created directory, or an error message.
+#[tauri::command]
+pub fn create_directory(parent_path: String, name: String) -> Result<String, String> {
+    if name.is_empty() {
+        return Err("Folder name cannot be empty".to_string());
+    }
+    if name.contains('/') || name.contains('\0') {
+        return Err("Folder name contains invalid characters".to_string());
+    }
+    let expanded_path = expand_tilde(&parent_path);
+    let mut new_path = PathBuf::from(&expanded_path);
+    new_path.push(&name);
+    std::fs::create_dir(&new_path).map_err(|e| match e.kind() {
+        std::io::ErrorKind::AlreadyExists => format!("'{}' already exists", name),
+        std::io::ErrorKind::PermissionDenied => {
+            format!("Permission denied: cannot create '{}' in '{}'", name, parent_path)
+        }
+        _ => format!("Failed to create folder: {}", e),
+    })?;
+    Ok(new_path.to_string_lossy().to_string())
+}
+
 // ============================================================================
 // On-demand virtual scrolling API
 // ============================================================================
@@ -545,6 +574,18 @@ fn expand_tilde(path: &str) -> String {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::fs;
+
+    fn create_test_dir(name: &str) -> PathBuf {
+        let dir = std::env::temp_dir().join(format!("cmdr_fs_cmd_test_{}", name));
+        let _ = fs::remove_dir_all(&dir);
+        fs::create_dir_all(&dir).expect("Failed to create test directory");
+        dir
+    }
+
+    fn cleanup_test_dir(path: &PathBuf) {
+        let _ = fs::remove_dir_all(path);
+    }
 
     #[test]
     fn test_expand_tilde() {
@@ -566,4 +607,57 @@ mod tests {
         let path = "/usr/local/bin";
         assert_eq!(expand_tilde(path), path);
     }
+
+    #[test]
+    fn test_create_directory_success() {
+        let tmp = create_test_dir("create_success");
+        let parent = tmp.to_string_lossy().to_string();
+        let result = create_directory(parent, "new-folder".to_string());
+        assert!(result.is_ok());
+        let created_path = result.unwrap();
+        assert!(PathBuf::from(&created_path).is_dir());
+        assert!(created_path.ends_with("new-folder"));
+        cleanup_test_dir(&tmp);
+    }
+
+    #[test]
+    fn test_create_directory_already_exists() {
+        let tmp = create_test_dir("create_exists");
+        let parent = tmp.to_string_lossy().to_string();
+        fs::create_dir(tmp.join("existing")).unwrap();
+        let result = create_directory(parent, "existing".to_string());
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("already exists"));
+        cleanup_test_dir(&tmp);
+    }
+
+    #[test]
+    fn test_create_directory_empty_name() {
+        let tmp = create_test_dir("create_empty");
+        let parent = tmp.to_string_lossy().to_string();
+        let result = create_directory(parent, "".to_string());
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("cannot be empty"));
+        cleanup_test_dir(&tmp);
+    }
+
+    #[test]
+    fn test_create_directory_invalid_chars() {
+        let tmp = create_test_dir("create_invalid");
+        let parent = tmp.to_string_lossy().to_string();
+        let result = create_directory(parent.clone(), "foo/bar".to_string());
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("invalid characters"));
+
+        let result = create_directory(parent, "foo\0bar".to_string());
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("invalid characters"));
+        cleanup_test_dir(&tmp);
+    }
+
+    #[test]
+    fn test_create_directory_nonexistent_parent() {
+        let result = create_directory("/nonexistent_path_12345".to_string(), "test".to_string());
+        assert!(result.is_err());
+    }
 }

apps/desktop/src-tauri/src/lib.rs

@@ -263,6 +263,7 @@ pub fn run() {
             commands::file_system::find_file_index,
             commands::file_system::resort_listing,
             commands::file_system::path_exists,
+            commands::file_system::create_directory,
             commands::file_system::benchmark_log,
             commands::file_system::copy_files,
             commands::file_system::move_files,

apps/desktop/src/lib/file-explorer/DualPaneExplorer.svelte

@@ -3,6 +3,7 @@
     import FilePane from './FilePane.svelte'
     import PaneResizer from './PaneResizer.svelte'
     import LoadingIcon from '../LoadingIcon.svelte'
+    import NewFolderDialog from './NewFolderDialog.svelte'
     import CopyDialog from '../write-operations/CopyDialog.svelte'
     import CopyProgressDialog from '../write-operations/CopyProgressDialog.svelte'
     import { toBackendIndices, toBackendCursorIndex } from '../write-operations/copy-dialog-utils'
@@ -29,10 +30,12 @@
         updateFocusedPane,
         getFileAt,
         getListingStats,
+        findFileIndex,
     } from '$lib/tauri-commands'
-    import type { VolumeInfo, SortColumn, SortOrder, NetworkHost } from './types'
+    import type { VolumeInfo, SortColumn, SortOrder, NetworkHost, DirectoryDiff } from './types'
     import { defaultSortOrders, DEFAULT_SORT_BY } from './types'
     import { ensureFontMetricsLoaded } from '$lib/font-metrics'
+    import { removeExtension } from './new-folder-utils'
     import {
         createHistory,
         push,
@@ -102,6 +105,15 @@
         previewId: string | null
     } | null>(null)
 
+    // New folder dialog state
+    let showNewFolderDialog = $state(false)
+    let newFolderDialogProps = $state<{
+        currentPath: string
+        listingId: string
+        showHiddenFiles: boolean
+        initialName: string
+    } | null>(null)
+
     // Navigation history for each pane (per-pane, session-only)
     // Initialize with default volume - will be updated on mount with actual state
     let leftHistory = $state<NavigationHistory>(createHistory(DEFAULT_VOLUME_ID, '~'))
@@ -534,6 +546,13 @@
             return
         }
 
+        // F7 - New folder dialog
+        if (e.key === 'F7') {
+            e.preventDefault()
+            void openNewFolderDialog()
+            return
+        }
+
         // Route to volume chooser if one is open
         if (routeToVolumeChooser(e)) {
             return
@@ -814,6 +833,90 @@
         return paths
     }
 
+    /** Gets the initial name for the new folder dialog (dir name as-is, file name without extension). */
+    async function getInitialFolderName(paneRef: FilePane | undefined, paneListingId: string): Promise<string> {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        const cursorIndex = paneRef?.getCursorIndex?.() as number | undefined
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        const hasParent = paneRef?.hasParentEntry?.() as boolean | undefined
+        if (cursorIndex === undefined || cursorIndex < 0) return ''
+        const backendIndex = hasParent ? cursorIndex - 1 : cursorIndex
+        if (backendIndex < 0) return ''
+        const entry = await getFileAt(paneListingId, backendIndex, showHiddenFiles)
+        if (!entry) return ''
+        return entry.isDirectory ? entry.name : removeExtension(entry.name)
+    }
+
+    async function openNewFolderDialog() {
+    /** Opens the new folder dialog. Pre-fills with the entry name under cursor. */
+        const isLeft = focusedPane === 'left'
+        const paneRef = isLeft ? leftPaneRef : rightPaneRef
+        const path = isLeft ? leftPath : rightPath
+
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        const paneListingId = paneRef?.getListingId?.() as string | undefined
+        if (!paneListingId) return
+
+        const initialName = await getInitialFolderName(paneRef, paneListingId)
+
+        newFolderDialogProps = {
+            currentPath: path,
+            listingId: paneListingId,
+            showHiddenFiles,
+            initialName,
+        }
+        showNewFolderDialog = true
+    }
+
+    function handleNewFolderCreated(folderName: string) {
+        const paneRef = focusedPane === 'left' ? leftPaneRef : rightPaneRef
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        const paneListingId = paneRef?.getListingId?.() as string | undefined
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        const hasParent = paneRef?.hasParentEntry?.() as boolean | undefined
+
+        showNewFolderDialog = false
+        newFolderDialogProps = null
+        containerElement?.focus()
+
+        // Wait for file watcher to pick up the new folder, then move cursor to it
+        if (!paneListingId) return
+        void moveCursorToNewFolder(paneListingId, folderName, paneRef, hasParent ?? false)
+    }
+
+    /** Waits for the file watcher diff, then moves cursor to the newly created folder. */
+    async function moveCursorToNewFolder(
+        paneListingId: string,
+        folderName: string,
+        paneRef: FilePane | undefined,
+        hasParent: boolean,
+    ) {
+        const unlisten = await listen<DirectoryDiff>('directory-diff', (event) => {
+            if (event.payload.listingId !== paneListingId) return
+            // Small delay to ensure listing cache is fully updated before querying
+            setTimeout(() => {
+                void findFileIndex(paneListingId, folderName, showHiddenFiles).then((index) => {
+                    if (index !== null) {
+                        const frontendIndex = hasParent ? index + 1 : index
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+                        paneRef?.setCursorIndex?.(frontendIndex)
+                        unlisten()
+                    }
+                })
+            }, 50)
+        })
+        // Clean up listener after 3 seconds if folder never appears
+        setTimeout(() => {
+            unlisten()
+        }, 3000)
+    }
+
+    function handleNewFolderCancel() {
+        showNewFolderDialog = false
+        newFolderDialogProps = null
+        containerElement?.focus()
+    }
+
     /** Opens the copy dialog with the current selection info. */
     async function openCopyDialog() {
         const isLeft = focusedPane === 'left'
@@ -1275,6 +1378,17 @@
     />
 {/if}
 
+{#if showNewFolderDialog && newFolderDialogProps}
+    <NewFolderDialog
+        currentPath={newFolderDialogProps.currentPath}
+        listingId={newFolderDialogProps.listingId}
+        showHiddenFiles={newFolderDialogProps.showHiddenFiles}
+        initialName={newFolderDialogProps.initialName}
+        onCreated={handleNewFolderCreated}
+        onCancel={handleNewFolderCancel}
+    />
+{/if}
+
 <style>
     .dual-pane-explorer {
         display: flex;