SMB reconnect: Guard handleDirect against double-fire

Both `runAttempt`'s success branch and the `smb-connection-changed` event listener can call `handleDirect` for the same cycle, which would fire `onSuccess` twice and double-trigger `loadDirectory` in the FilePane. The new guard checks the entry's baseline shape (`status: 'waiting'`, no timer, `attemptIndex: 0`) and returns early when there's nothing to clean up. The runAttempt-side call stays as a defensive backstop — `handleDirect` is now safely idempotent.

Adds a regression test that triggers both paths in the same cycle and asserts `onSuccess` fires exactly once.

Author: vdavid

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

@@ -175,6 +175,24 @@ describe('smbReconnectManager', () => {
     expect(smbReconnectManager.getState('vol-refcount')).toBeNull()
   })
 
+  it('handleDirect is idempotent — onSuccess fires exactly once per cycle', async () => {
+    // Race scenario: both the `direct` event and the awaited `reconnectSmbVolume`
+    // success path could each trigger `handleDirect`. The idempotency guard
+    // ensures `onSuccess` only fires once.
+    await smbReconnectManager.init()
+    const onSuccess = vi.fn()
+    const unsub = smbReconnectManager.subscribe('vol-once', onSuccess)
+    smbReconnectManager.startCycle('vol-once')
+    // Resolve `reconnectSmbVolume` AND emit the `direct` event (simulating both
+    // paths racing to clean up). Only one should win and notify.
+    mockReconnect.mockResolvedValueOnce(undefined)
+    await vi.advanceTimersByTimeAsync(RECONNECT_DELAYS_MS[0])
+    emit('vol-once', 'direct')
+    expect(onSuccess).toHaveBeenCalledTimes(1)
+
+    unsub()
+  })
+
   it('two subscribers see the same state object (one cycle, both panes)', async () => {
     await smbReconnectManager.init()
     const unsub1 = smbReconnectManager.subscribe('vol-shared')

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

@@ -191,6 +191,12 @@ class SmbReconnectManager {
   private handleDirect(volumeId: string): void {
     const entry = this.map.get(volumeId)
     if (!entry) return
+    // Idempotent: if no cycle is in flight (state is the baseline + no timer),
+    // there's nothing to clean up and no subscribers to notify. This guards
+    // against double-firing when both `runAttempt`'s success branch and the
+    // `smb-connection-changed` event fire — whichever runs first wins.
+    const noActiveCycle = entry.state.status === 'waiting' && entry.timerId === null && entry.state.attemptIndex === 0
+    if (noActiveCycle) return
     if (entry.timerId) clearTimeout(entry.timerId)
     entry.timerId = null
     entry.state = freshState()
@@ -238,11 +244,9 @@ class SmbReconnectManager {
 
     try {
       await reconnectSmbVolume(volumeId)
-      // Success — let the `smb-connection-changed` listener handle cleanup so
-      // the path that runs is the same whether success comes from us or from
-      // an unrelated trigger (lazy nav, manual reconnect from another window).
-      // As a defensive backstop in case the event never arrives, also clean up
-      // here. `handleDirect` is idempotent.
+      // Success — defensive backstop in case the `smb-connection-changed`
+      // event somehow doesn't arrive (unexpected, but `handleDirect` is
+      // idempotent so calling both paths is safe).
       this.handleDirect(volumeId)
     } catch (e) {
       log.info('Reconnect attempt {attempt} for {volumeId} failed: {error}', {