Save last dir for each volume

- Also add docs into `persistence-stores.md`

Author: vdavid

docs/features/persistence-stores.md

@@ -0,0 +1,56 @@
+# Persistence stores
+
+Rusty Commander uses three persistent storage mechanisms, each for a distinct purpose. All are stored in the app's data
+directory (on macOS: `~/Library/Application Support/com.rustycommander.app/`).
+
+## 1. App status store (`app-status.json`)
+
+**Purpose**: Stores the current state of the application - where the user "is" in the app.
+
+**File**: `src/lib/app-status-store.ts`
+
+**Contents**:
+
+- `leftPath`, `rightPath` - Current directory paths for each pane
+- `focusedPane` - Which pane (`left` or `right`) has focus
+- `leftViewMode`, `rightViewMode` - View mode (`full` or `brief`) for each pane
+- `leftVolumeId`, `rightVolumeId` - Currently selected volume for each pane
+- `lastUsedPaths` - Map of `volumeId` -> last-used path; used to restore position when switching volumes
+
+**Restored**: On app startup. Paths are validated and gracefully fall back to parent dirs or home if they no longer
+exist.
+
+## 2. Settings store (`settings.json`)
+
+**Purpose**: Stores user preferences—how the user likes to work.
+
+**File**: `src/lib/settings-store.ts`
+
+**Contents**:
+
+- `showHiddenFiles` - Whether to show hidden files (also synced with the View menu)
+- `fullDiskAccessChoice` - Full disk access permission state (`allow`, `deny`, or `notAskedYet`)
+
+**Restored**: On app startup. Settings can also be changed via the menu and are persisted immediately.
+
+## 3. Window state (plugin-managed)
+
+**Purpose**: Stores window size and position.
+
+**File**: Managed by `@tauri-apps/plugin-window-state` (stores in a plugin-specific file)
+
+**Contents**:
+
+- Window position, size, and display
+
+**Restored**: Automatically by the plugin on window creation. By default, saves on quit, but we also save on resize (see
+`src/lib/window-state.ts`) to persist across hot reloads.
+
+## Design philosophy
+
+- **Status vs settings**: Status is ephemeral state (where you are), settings are preferences (how you like things). If
+  the user resets "status", they should start fresh. If they reset "settings", they should get default preferences back.
+- **Per-volume paths**: The `lastUsedPaths` map in app-status allows remembering where the user was on each volume.
+  Switching volumes restores the last used directory. Favorites are shortcuts within volumes, so they don't store
+  separate paths—they use the containing volume's path storage.
+- **Graceful degradation**: All stores silently fail if persistence fails—the app works with defaults.

docs/todo.md

@@ -1,10 +1,6 @@
 ## Listing
 
-- [x] Allow user to go up from favorites. In the volume selector, we currently put a tick next to the selected volume,
-      but for favorites, they should never have the checkmark. When selected, the volume containing them should be
-      ticked. And the "root" folder of the favorite should not actually be a root folder, but should contain ".." and
-      act in every way like the volume that contains it. Basically, favorites should just be shortcuts, not volumes.
-- [ ] Save to state the last used directory per volume. Save it to the same state store where we save showHiddenFiles
+- [x] Save to state the last used directory per volume. Save it to the same state store where we save showHiddenFiles
       and the such. Use it when switching volumes. (Favorites are not volumes, they are just shortcuts to directories,
       so their state belongs to the volume that contains them.)
 - [ ] Add Back/Forward feature. I want to add a Back/Forward feature to let the user navigate back and forth between

src/lib/app-status-store.ts

@@ -126,6 +126,49 @@ export async function saveAppStatus(status: Partial<AppStatus>): Promise<void> {
         if (status.rightVolumeId !== undefined) {
             await store.set('rightVolumeId', status.rightVolumeId)
         }
+        await store.save()
+    } catch {
+        // Silently fail - persistence is nice-to-have
+    }
+}
+
+/** Map of volumeId -> last used path for that volume */
+export type VolumePathMap = Record<string, string>
+
+function isValidPathMap(value: unknown): value is VolumePathMap {
+    if (typeof value !== 'object' || value === null) return false
+    return Object.entries(value).every(([k, v]) => typeof k === 'string' && typeof v === 'string')
+}
+
+/**
+ * Gets the last used path for a specific volume.
+ * Returns undefined if no path is stored.
+ */
+export async function getLastUsedPathForVolume(volumeId: string): Promise<string | undefined> {
+    try {
+        const store = await getStore()
+        const lastUsedPaths = await store.get('lastUsedPaths')
+        if (isValidPathMap(lastUsedPaths)) {
+            return lastUsedPaths[volumeId]
+        }
+        return undefined
+    } catch {
+        return undefined
+    }
+}
+
+/**
+ * Saves the last used path for a specific volume.
+ * This is more efficient than loading/saving the full status.
+ */
+export async function saveLastUsedPathForVolume(volumeId: string, path: string): Promise<void> {
+    try {
+        const store = await getStore()
+        const lastUsedPaths = await store.get('lastUsedPaths')
+        const paths: VolumePathMap = isValidPathMap(lastUsedPaths) ? lastUsedPaths : {}
+        paths[volumeId] = path
+        await store.set('lastUsedPaths', paths)
+        await store.save()
     } catch {
         // Silently fail - persistence is nice-to-have
     }

src/lib/file-explorer/DualPaneExplorer.svelte

@@ -2,13 +2,20 @@
     import { onMount, onDestroy } from 'svelte'
     import FilePane from './FilePane.svelte'
     import LoadingIcon from '../LoadingIcon.svelte'
-    import { loadAppStatus, saveAppStatus, type ViewMode } from '$lib/app-status-store'
+    import {
+        loadAppStatus,
+        saveAppStatus,
+        getLastUsedPathForVolume,
+        saveLastUsedPathForVolume,
+        type ViewMode,
+    } from '$lib/app-status-store'
     import { loadSettings, saveSettings, subscribeToSettingsChanges } from '$lib/settings-store'
     import {
         pathExists,
         listen,
         listVolumes,
         getDefaultVolumeId,
+        findContainingVolume,
         DEFAULT_VOLUME_ID,
         type UnlistenFn,
     } from '$lib/tauri-commands'
@@ -40,27 +47,63 @@
     function handleLeftPathChange(path: string) {
         leftPath = path
         void saveAppStatus({ leftPath: path })
+        void saveLastUsedPathForVolume(leftVolumeId, path)
         // Re-focus to maintain keyboard handling after navigation
         containerElement?.focus()
     }
 
     function handleRightPathChange(path: string) {
         rightPath = path
         void saveAppStatus({ rightPath: path })
+        void saveLastUsedPathForVolume(rightVolumeId, path)
         // Re-focus to maintain keyboard handling after navigation
         containerElement?.focus()
     }
 
-    function handleLeftVolumeChange(volumeId: string, volumePath: string, targetPath: string) {
+    async function handleLeftVolumeChange(volumeId: string, volumePath: string, targetPath: string) {
+        // Save the current path for the old volume before switching
+        void saveLastUsedPathForVolume(leftVolumeId, leftPath)
+
+        const pathToNavigate = await determineNavigationPath(volumeId, volumePath, targetPath)
+
         leftVolumeId = volumeId
-        leftPath = targetPath
-        void saveAppStatus({ leftVolumeId: volumeId, leftPath: targetPath })
+        leftPath = pathToNavigate
+        void saveAppStatus({ leftVolumeId: volumeId, leftPath: pathToNavigate })
     }
 
-    function handleRightVolumeChange(volumeId: string, volumePath: string, targetPath: string) {
+    async function handleRightVolumeChange(volumeId: string, volumePath: string, targetPath: string) {
+        // Save the current path for the old volume before switching
+        void saveLastUsedPathForVolume(rightVolumeId, rightPath)
+
+        const pathToNavigate = await determineNavigationPath(volumeId, volumePath, targetPath)
+
         rightVolumeId = volumeId
-        rightPath = targetPath
-        void saveAppStatus({ rightVolumeId: volumeId, rightPath: targetPath })
+        rightPath = pathToNavigate
+        void saveAppStatus({ rightVolumeId: volumeId, rightPath: pathToNavigate })
+    }
+
+    /**
+     * Determines which path to navigate to when switching volumes.
+     * - If targetPath !== volumePath: user selected a favorite → go there directly
+     * - Otherwise: look up last used path, or default to ~ for main volume, volume root for others
+     */
+    async function determineNavigationPath(volumeId: string, volumePath: string, targetPath: string): Promise<string> {
+        // User selected a favorite - go to the favorite's path directly
+        if (targetPath !== volumePath) {
+            return targetPath
+        }
+
+        // Look up the last used path for this volume
+        const lastUsedPath = await getLastUsedPathForVolume(volumeId)
+        if (lastUsedPath && (await pathExists(lastUsedPath))) {
+            return lastUsedPath
+        }
+
+        // Default: ~ for main volume (root), volume path for others
+        if (volumeId === DEFAULT_VOLUME_ID) {
+            return '~'
+        }
+        return volumePath
     }
 
     function handleLeftFocus() {
@@ -126,10 +169,15 @@
         leftViewMode = status.leftViewMode
         rightViewMode = status.rightViewMode
 
-        // Validate persisted volume IDs exist, fallback to default if not
+        // Determine the correct volume IDs by finding which volume contains each path
+        // This is more reliable than trusting the stored volumeId, which may be stale
         const defaultId = await getDefaultVolumeId()
-        leftVolumeId = volumes.some((v) => v.id === status.leftVolumeId) ? status.leftVolumeId : defaultId
-        rightVolumeId = volumes.some((v) => v.id === status.rightVolumeId) ? status.rightVolumeId : defaultId
+        const [leftContaining, rightContaining] = await Promise.all([
+            findContainingVolume(status.leftPath),
+            findContainingVolume(status.rightPath),
+        ])
+        leftVolumeId = leftContaining?.id ?? defaultId
+        rightVolumeId = rightContaining?.id ?? defaultId
 
         initialized = true
 

src/lib/file-explorer/DualPaneExplorer.test.ts

@@ -13,6 +13,8 @@ vi.mock('$lib/app-status-store', () => ({
         rightVolumeId: 'root',
     }),
     saveAppStatus: vi.fn().mockResolvedValue(undefined),
+    getLastUsedPathForVolume: vi.fn().mockResolvedValue(undefined),
+    saveLastUsedPathForVolume: vi.fn().mockResolvedValue(undefined),
 }))
 
 vi.mock('@tauri-apps/api/event', () => ({
@@ -81,11 +83,13 @@ describe('DualPaneExplorer', () => {
         const target = document.createElement('div')
         mount(DualPaneExplorer, { target })
 
-        // Wait for async initialization (paths, volumes, settings)
-        await tick()
-        await tick()
-        await tick()
-        await tick()
+        // Wait for async initialization (paths, volumes, settings, findContainingVolume)
+        // The initialization now includes more async calls, so we need more ticks
+        for (let i = 0; i < 10; i++) {
+            await tick()
+        }
+        // Small additional delay to ensure all promises resolve
+        await new Promise((resolve) => setTimeout(resolve, 10))
         await tick()
 
         const panes = target.querySelectorAll('.file-pane')

src/lib/file-explorer/FilePane.svelte

@@ -503,8 +503,10 @@
             {currentPath}
             onVolumeChange={(newVolumeId: string, newVolumePath: string, targetPath: string) => {
                 // Navigate to the target path (may differ from volume root for favorites)
+                // Note: We intentionally don't call onPathChange here - the volume change handler
+                // in DualPaneExplorer takes care of saving both the old volume's path and the new path.
+                // Calling onPathChange would save the new path under the OLD volume ID (race condition).
                 currentPath = targetPath
-                onPathChange?.(targetPath)
                 onVolumeChange?.(newVolumeId, newVolumePath, targetPath)
                 void loadDirectory(targetPath)
             }}