SMB: Live reconnect UX with backoff cycle (frontend)

When the smb2 session for a direct-SMB volume drops, the pane swaps to a `SmbReconnectingView` that runs a 5-attempt backoff cycle (2/4/8/16/30s, total 60s). Both panes on the same share share a single cycle; success re-runs `loadDirectory` automatically; give-up swaps to the existing unreachable banner with a Disconnect button.

- New `smb-reconnect-manager.svelte.ts`: per-volume Svelte store, refcounted subscriptions (`smbReconnectManager.subscribe`), backoff timer, single-flight via the backend's reconnect lock. Listens to `smb-connection-changed` events. Cycle stops when the last subscriber leaves; the connection stays Disconnected so lazy reconnect on next nav can pick up.
- New `SmbReconnectingView.svelte`: title, spinner, progress bar (0→`currentDelayMs`, requestAnimationFrame-driven), body lines computed dynamically from `RECONNECT_DELAYS_MS` (the backoff array is the only place these numbers exist), three buttons (Retry now / Cancel / Disconnect) with tooltips clarifying the difference.
- `FilePane.svelte`: subscribes to the manager whenever on an SMB share. Swaps to the reconnecting view while a cycle is active; swaps to `VolumeUnreachableBanner` (with a new Disconnect button) on give-up. The lazy nav-time path: if the user opens an already-Disconnected share, the effect kicks off the cycle so the view comes up immediately instead of after a listing-error round-trip.
- `VolumeUnreachableBanner.svelte`: extended with an `smbGaveUp` variant that swaps the "Open home folder" button for "Disconnect" and adapts the detail line.
- `volume-store.svelte.ts`: also listens for `smb-connection-changed` so `currentVolumeInfo.smbConnectionState` and the picker dot update the moment a session flips, without waiting for the next `volumes-changed`.
- `SmbConnectionState` enum gains a third `Disconnected` variant. `SmbVolume::smb_connection_state()` now returns `Some(Disconnected)` instead of `None` when the session is dead, so the FE can distinguish "not an SMB volume" from "SMB volume in trouble".
- `Disconnect` currently behaves like `Cancel` plus a navigation away — there's no clean per-volume "drop SMB session" backend command yet. Users can still eject via the volume picker. Wiring an explicit disconnect command is a follow-up.

Tests:
- 14 unit tests for the manager: backoff progression, give-up after exhausting the array, success path via the event, "Retry now" reset, "Cancel" cleanup, refcount semantics, two-subscriber sharing.
- Pure-helper tests: `ordinalCount`, `reconnectProgressMessage` for every attempt index (including the no-body-2 first attempt and the "final attempt" wording).
- Tier-3 a11y tests for `SmbReconnectingView` in waiting (first attempt, mid-cycle) and attempting states.

Author: vdavid

apps/desktop/src-tauri/src/file_system/volume/mod.rs

@@ -17,17 +17,26 @@ use std::pin::Pin;
 use std::sync::atomic::AtomicBool;
 use tokio::sync::mpsc;
 
-/// SMB connection state for the frontend indicator.
+/// SMB connection state for the frontend indicator and the reconnect UI.
 ///
 /// `Direct` means Cmdr's smb2 session is active (fast path).
 /// `OsMount` means only the OS mount is alive (fallback path).
+/// `Disconnected` means an SmbVolume exists but its smb2 session is broken — the
+/// frontend reconnect manager owns the recovery cycle.
+///
+/// Non-SMB volumes return `None` from `Volume::smb_connection_state()` (trait
+/// default). The frontend uses this to distinguish "this isn't an SMB volume"
+/// (no value) from "this is an SMB volume in trouble" (Some(Disconnected)).
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum SmbConnectionState {
     /// smb2 session active — fast path (green indicator).
     Direct,
     /// Using OS mount only — slower fallback (yellow indicator).
     OsMount,
+    /// Cmdr's smb2 session has dropped. The frontend swaps to `SmbReconnectingView`
+    /// and the per-volume reconnect manager runs the backoff cycle.
+    Disconnected,
 }
 
 /// Default volume ID for the root filesystem.

apps/desktop/src-tauri/src/file_system/volume/smb.rs

@@ -1796,11 +1796,14 @@ impl Volume for SmbVolume {
     }
 
     fn smb_connection_state(&self) -> Option<SmbConnectionState> {
-        match self.connection_state() {
-            ConnectionState::Direct => Some(SmbConnectionState::Direct),
-            ConnectionState::OsMount => Some(SmbConnectionState::OsMount),
-            ConnectionState::Disconnected => None,
-        }
+        // SmbVolume always returns `Some` so the frontend can distinguish
+        // "not an SMB volume" (None) from "SMB volume in trouble"
+        // (Some(Disconnected)). The reconnect manager keys off the latter.
+        Some(match self.connection_state() {
+            ConnectionState::Direct => SmbConnectionState::Direct,
+            ConnectionState::OsMount => SmbConnectionState::OsMount,
+            ConnectionState::Disconnected => SmbConnectionState::Disconnected,
+        })
     }
 
     fn attempt_reconnect<'a>(&'a self) -> Pin<Box<dyn Future<Output = Result<(), VolumeError>> + Send + 'a>> {

apps/desktop/src/lib/file-explorer/network/CLAUDE.md

@@ -4,13 +4,14 @@ SMB network discovery UI: host list, per-host share list, login form, and a sing
 
 ## Key files
 
-| File                           | Purpose                                                                   |
-| ------------------------------ | ------------------------------------------------------------------------- |
-| `network-store.svelte.ts`      | Module-level `$state` singleton for all network data                      |
-| `NetworkBrowser.svelte`        | Host list table — rendered when pane is on the `network` volume           |
-| `ShareBrowser.svelte`          | Share list for a specific host, handles auth flow                         |
-| `NetworkLoginForm.svelte`      | Credential form rendered inside `ShareBrowser`                            |
-| `ConnectToServerDialog.svelte` | Modal dialog for manually connecting to a server by address/IP/smb:// URL |
+| File                              | Purpose                                                                                                                                                                                                                                          |
+| --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `network-store.svelte.ts`         | Module-level `$state` singleton for all network data                                                                                                                                                                                             |
+| `NetworkBrowser.svelte`           | Host list table — rendered when pane is on the `network` volume                                                                                                                                                                                  |
+| `ShareBrowser.svelte`             | Share list for a specific host, handles auth flow                                                                                                                                                                                                |
+| `NetworkLoginForm.svelte`         | Credential form rendered inside `ShareBrowser`                                                                                                                                                                                                   |
+| `ConnectToServerDialog.svelte`    | Modal dialog for manually connecting to a server by address/IP/smb:// URL                                                                                                                                                                        |
+| `smb-reconnect-manager.svelte.ts` | Per-volume backoff cycle that re-establishes a Disconnected `SmbVolume`. Listens to `smb-connection-changed` from the backend, drives the FE state machine for `SmbReconnectingView`, exposes `subscribe` / `startCycle` / `retryNow` / `cancel` |
 
 ## `network-store.svelte.ts`
 

apps/desktop/src/lib/file-explorer/network/smb-reconnect-manager.svelte.test.ts

@@ -0,0 +1,225 @@
+/**
+ * Unit tests for the per-volume SMB reconnect manager.
+ *
+ * Covers: backoff progression on repeated failures, success path via the
+ * `smb-connection-changed` event, "Retry now" reset semantics, "Cancel"
+ * cleanup, refcounted subscriptions, give-up after exhausting the array,
+ * and the pure display helpers (`ordinalCount`, `reconnectProgressMessage`).
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+
+// Hoisted mocks: must run before importing the module under test.
+const mockReconnect = vi.fn<(volumeId: string) => Promise<void>>()
+const mockListen = vi.fn<(event: string, handler: (e: { payload: unknown }) => void) => Promise<() => void>>()
+let lastEventHandler: ((e: { payload: unknown }) => void) | null = null
+
+vi.mock('$lib/tauri-commands', () => ({
+  reconnectSmbVolume: (id: string) => mockReconnect(id),
+}))
+
+vi.mock('@tauri-apps/api/event', () => ({
+  listen: (event: string, handler: (e: { payload: unknown }) => void) => {
+    lastEventHandler = handler
+    return mockListen(event, handler)
+  },
+}))
+
+import {
+  smbReconnectManager,
+  RECONNECT_DELAYS_MS,
+  TOTAL_ATTEMPTS,
+  ordinalCount,
+  reconnectProgressMessage,
+} from './smb-reconnect-manager.svelte'
+
+/** Drives the listener as if the backend emitted the event. */
+function emit(volumeId: string, state: 'direct' | 'disconnected'): void {
+  if (!lastEventHandler) throw new Error("init() was not called or didn't install a listener")
+  lastEventHandler({ payload: { volumeId, state } })
+}
+
+describe('smbReconnectManager', () => {
+  beforeEach(() => {
+    vi.useFakeTimers()
+    mockReconnect.mockReset()
+    mockListen.mockReset()
+    mockListen.mockResolvedValue(() => {
+      lastEventHandler = null
+    })
+    // The manager's internal map is a singleton across tests; the tests use a
+    // fresh volumeId each so leftover entries don't interfere.
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it('does not start a cycle without subscribers', async () => {
+    await smbReconnectManager.init()
+    emit('vol-no-subs', 'disconnected')
+    // Advance past every backoff delay; nothing should have fired.
+    await vi.advanceTimersByTimeAsync(RECONNECT_DELAYS_MS.reduce((a, b) => a + b, 0) + 100)
+    expect(mockReconnect).not.toHaveBeenCalled()
+    expect(smbReconnectManager.getState('vol-no-subs')).toBeNull()
+  })
+
+  it('starts a cycle on disconnected event when subscribed', async () => {
+    await smbReconnectManager.init()
+    const unsub = smbReconnectManager.subscribe('vol-1')
+    emit('vol-1', 'disconnected')
+    // Right after the event we're in the first "waiting" phase.
+    const state1 = smbReconnectManager.getState('vol-1')
+    expect(state1?.status).toBe('waiting')
+    expect(state1?.attemptIndex).toBe(0)
+    expect(state1?.currentDelayMs).toBe(RECONNECT_DELAYS_MS[0])
+
+    // Wait through the first delay → first attempt fires.
+    mockReconnect.mockRejectedValueOnce(new Error('still down'))
+    await vi.advanceTimersByTimeAsync(RECONNECT_DELAYS_MS[0])
+    expect(mockReconnect).toHaveBeenCalledTimes(1)
+    // Failed → next delay scheduled.
+    const state2 = smbReconnectManager.getState('vol-1')
+    expect(state2?.status).toBe('waiting')
+    expect(state2?.attemptIndex).toBe(1)
+    expect(state2?.currentDelayMs).toBe(RECONNECT_DELAYS_MS[1])
+
+    smbReconnectManager.cancel('vol-1')
+    unsub()
+  })
+
+  it('gives up after exhausting the backoff array', async () => {
+    await smbReconnectManager.init()
+    const unsub = smbReconnectManager.subscribe('vol-giveup')
+    mockReconnect.mockRejectedValue(new Error('still down'))
+
+    smbReconnectManager.startCycle('vol-giveup')
+    // Advance through all attempts. Each iteration: wait the delay, then fire.
+    for (const delay of RECONNECT_DELAYS_MS) {
+      await vi.advanceTimersByTimeAsync(delay)
+    }
+    const state = smbReconnectManager.getState('vol-giveup')
+    expect(state?.status).toBe('gave-up')
+    expect(mockReconnect).toHaveBeenCalledTimes(TOTAL_ATTEMPTS)
+
+    smbReconnectManager.cancel('vol-giveup')
+    unsub()
+  })
+
+  it('clears state and notifies subscribers on a `direct` event', async () => {
+    await smbReconnectManager.init()
+    const onSuccess = vi.fn()
+    const unsub = smbReconnectManager.subscribe('vol-ok', onSuccess)
+    emit('vol-ok', 'disconnected')
+    expect(smbReconnectManager.getState('vol-ok')?.status).toBe('waiting')
+
+    emit('vol-ok', 'direct')
+    expect(smbReconnectManager.getState('vol-ok')).toBeNull()
+    expect(onSuccess).toHaveBeenCalledTimes(1)
+
+    unsub()
+  })
+
+  it('"Retry now" fires immediately and resumes backoff at attempt 2', async () => {
+    await smbReconnectManager.init()
+    const unsub = smbReconnectManager.subscribe('vol-retry')
+    smbReconnectManager.startCycle('vol-retry')
+    // We're in attempt-0 wait. Skip ahead a bit, then click Retry now.
+    await vi.advanceTimersByTimeAsync(500)
+    mockReconnect.mockRejectedValueOnce(new Error('still down'))
+    smbReconnectManager.retryNow('vol-retry')
+    // The retry runs synchronously through the awaited reconnect call —
+    // flush microtasks so the failure handler runs.
+    await vi.advanceTimersByTimeAsync(0)
+    expect(mockReconnect).toHaveBeenCalledTimes(1)
+    // After the failure, we're scheduled for the SECOND attempt — index 1
+    // (with delay RECONNECT_DELAYS_MS[1]), not back to index 0.
+    const state = smbReconnectManager.getState('vol-retry')
+    expect(state?.status).toBe('waiting')
+    expect(state?.attemptIndex).toBe(1)
+    expect(state?.currentDelayMs).toBe(RECONNECT_DELAYS_MS[1])
+
+    smbReconnectManager.cancel('vol-retry')
+    unsub()
+  })
+
+  it('"Cancel" stops the timer and clears state', async () => {
+    await smbReconnectManager.init()
+    const unsub = smbReconnectManager.subscribe('vol-cancel')
+    smbReconnectManager.startCycle('vol-cancel')
+    expect(smbReconnectManager.getState('vol-cancel')?.status).toBe('waiting')
+
+    smbReconnectManager.cancel('vol-cancel')
+    expect(smbReconnectManager.getState('vol-cancel')).toBeNull()
+
+    // Even after waiting through every delay, no attempt fires.
+    await vi.advanceTimersByTimeAsync(RECONNECT_DELAYS_MS.reduce((a, b) => a + b, 0) + 100)
+    expect(mockReconnect).not.toHaveBeenCalled()
+
+    unsub()
+  })
+
+  it('refcounts subscriptions: cycle stops when the last subscriber leaves', async () => {
+    await smbReconnectManager.init()
+    const unsub1 = smbReconnectManager.subscribe('vol-refcount')
+    const unsub2 = smbReconnectManager.subscribe('vol-refcount')
+    smbReconnectManager.startCycle('vol-refcount')
+    expect(smbReconnectManager.getState('vol-refcount')?.status).toBe('waiting')
+
+    unsub1()
+    // Still subscribed → cycle continues, state preserved.
+    expect(smbReconnectManager.getState('vol-refcount')?.status).toBe('waiting')
+
+    unsub2()
+    // Last subscriber left → entry cleared.
+    expect(smbReconnectManager.getState('vol-refcount')).toBeNull()
+  })
+
+  it('two subscribers see the same state object (one cycle, both panes)', async () => {
+    await smbReconnectManager.init()
+    const unsub1 = smbReconnectManager.subscribe('vol-shared')
+    const unsub2 = smbReconnectManager.subscribe('vol-shared')
+    smbReconnectManager.startCycle('vol-shared')
+    const a = smbReconnectManager.getState('vol-shared')
+    const b = smbReconnectManager.getState('vol-shared')
+    expect(a).not.toBeNull()
+    expect(b).toEqual(a)
+
+    smbReconnectManager.cancel('vol-shared')
+    unsub1()
+    unsub2()
+  })
+})
+
+describe('reconnect display helpers', () => {
+  describe('ordinalCount', () => {
+    it.each([
+      [1, 'once'],
+      [2, 'twice'],
+      [3, '3 times'],
+      [10, '10 times'],
+    ])('formats %i → %s', (n, expected) => {
+      expect(ordinalCount(n)).toBe(expected)
+    })
+  })
+
+  describe('reconnectProgressMessage', () => {
+    it('returns null for the very first attempt (no body 2)', () => {
+      expect(reconnectProgressMessage(0)).toBeNull()
+    })
+
+    it('formats the body 2 message for each attempt index', () => {
+      // With the default 5-attempt array:
+      // attemptIndex=1 → upcoming attempt 2, 3 more after this (3, 4, 5)
+      expect(reconnectProgressMessage(1)).toBe('Retried once, will try it 3 times more after this.')
+      // attemptIndex=2 → upcoming attempt 3, 2 more after this (4, 5)
+      expect(reconnectProgressMessage(2)).toBe('Retried twice, will try it twice more after this.')
+      // attemptIndex=3 → upcoming attempt 4, 1 more after this (5)
+      expect(reconnectProgressMessage(3)).toBe('Retried 3 times, will try it once more after this.')
+      // attemptIndex=4 → final attempt
+      expect(reconnectProgressMessage(4)).toBe(
+        'Retried 4 times, this is the final attempt — will drop the connection if it fails.',
+      )
+    })
+  })
+})