Refactor useConnectionStatus hook with adaptive polling and remove unused deps

Author: brandonkachen

cli/src/hooks/__tests__/use-connection-status.test.ts

@@ -0,0 +1,112 @@
+import { describe, test, expect } from 'bun:test'
+
+import { getNextInterval } from '../use-connection-status'
+
+/**
+ * Tests for the adaptive health check interval logic.
+ * 
+ * These tests verify the core exponential backoff algorithm that determines
+ * how frequently health checks should run based on consecutive successful checks.
+ */
+
+describe('useConnectionStatus - adaptive interval logic', () => {
+  describe('getNextInterval', () => {
+    test('returns 10s for 0-2 consecutive successes', () => {
+      expect(getNextInterval(0)).toBe(10_000)
+      expect(getNextInterval(1)).toBe(10_000)
+      expect(getNextInterval(2)).toBe(10_000)
+    })
+
+    test('returns 30s for 3-5 consecutive successes', () => {
+      expect(getNextInterval(3)).toBe(30_000)
+      expect(getNextInterval(4)).toBe(30_000)
+      expect(getNextInterval(5)).toBe(30_000)
+    })
+
+    test('returns 60s for 6-9 consecutive successes', () => {
+      expect(getNextInterval(6)).toBe(60_000)
+      expect(getNextInterval(7)).toBe(60_000)
+      expect(getNextInterval(8)).toBe(60_000)
+      expect(getNextInterval(9)).toBe(60_000)
+    })
+
+    test('returns 2min for 10-14 consecutive successes', () => {
+      expect(getNextInterval(10)).toBe(120_000)
+      expect(getNextInterval(11)).toBe(120_000)
+      expect(getNextInterval(14)).toBe(120_000)
+    })
+
+    test('returns 5min for 15-19 consecutive successes', () => {
+      expect(getNextInterval(15)).toBe(300_000)
+      expect(getNextInterval(16)).toBe(300_000)
+      expect(getNextInterval(19)).toBe(300_000)
+    })
+
+    test('returns 10min (max) for 20+ consecutive successes', () => {
+      expect(getNextInterval(20)).toBe(600_000)
+      expect(getNextInterval(25)).toBe(600_000)
+      expect(getNextInterval(100)).toBe(600_000)
+      expect(getNextInterval(1000)).toBe(600_000)
+    })
+  })
+
+  describe('interval progression', () => {
+    test('progresses through all thresholds in order', () => {
+      const progression = [
+        { successes: 0, expectedInterval: 10_000 },
+        { successes: 3, expectedInterval: 30_000 },
+        { successes: 6, expectedInterval: 60_000 },
+        { successes: 10, expectedInterval: 120_000 },
+        { successes: 15, expectedInterval: 300_000 },
+        { successes: 20, expectedInterval: 600_000 },
+      ]
+
+      for (const { successes, expectedInterval } of progression) {
+        expect(getNextInterval(successes)).toBe(expectedInterval)
+      }
+    })
+
+    test('intervals increase monotonically', () => {
+      let previousInterval = 0
+      // Test first occurrence of each threshold
+      const testPoints = [0, 3, 6, 10, 15, 20, 50]
+
+      for (const successes of testPoints) {
+        const interval = getNextInterval(successes)
+        expect(interval).toBeGreaterThanOrEqual(previousInterval)
+        previousInterval = interval
+      }
+    })
+  })
+
+  describe('edge cases', () => {
+    test('handles negative values (treated as 0)', () => {
+      // In practice, consecutive successes should never be negative,
+      // but the function should handle it gracefully
+      expect(getNextInterval(-1)).toBe(10_000)
+      expect(getNextInterval(-100)).toBe(10_000)
+    })
+
+    test('handles very large values', () => {
+      expect(getNextInterval(Number.MAX_SAFE_INTEGER)).toBe(600_000)
+    })
+  })
+
+  describe('boundary conditions', () => {
+    test('uses correct interval at exact threshold boundaries', () => {
+      // At threshold - 1: should use previous interval
+      expect(getNextInterval(2)).toBe(10_000) // Just before 3
+      expect(getNextInterval(5)).toBe(30_000) // Just before 6
+      expect(getNextInterval(9)).toBe(60_000) // Just before 10
+      expect(getNextInterval(14)).toBe(120_000) // Just before 15
+      expect(getNextInterval(19)).toBe(300_000) // Just before 20
+
+      // At threshold: should use new interval
+      expect(getNextInterval(3)).toBe(30_000)
+      expect(getNextInterval(6)).toBe(60_000)
+      expect(getNextInterval(10)).toBe(120_000)
+      expect(getNextInterval(15)).toBe(300_000)
+      expect(getNextInterval(20)).toBe(600_000)
+    })
+  })
+})

cli/src/hooks/use-connection-status.ts

@@ -3,40 +3,124 @@ import { useEffect, useState } from 'react'
 import { getCodebuffClient } from '../utils/codebuff-client'
 import { logger } from '../utils/logger'
 
+// Adaptive health check interval configuration
+// Progressively increases polling interval based on consecutive successful checks
+export const HEALTH_CHECK_CONFIG = {
+  // Initial interval after startup or failure (ms)
+  INITIAL_INTERVAL: 10_000, // 10 seconds
+  // Interval thresholds based on consecutive successful checks
+  INTERVALS: [
+    { successCount: 3, interval: 30_000 }, // 30 seconds after 3 successes
+    { successCount: 6, interval: 60_000 }, // 1 minute after 6 successes
+    { successCount: 10, interval: 120_000 }, // 2 minutes after 10 successes
+    { successCount: 15, interval: 300_000 }, // 5 minutes after 15 successes
+    { successCount: 20, interval: 600_000 }, // 10 minutes after 20 successes
+  ],
+} as const
+
+/**
+ * Calculates the next health check interval based on consecutive successful checks
+ * Exported for testing purposes
+ */
+export function getNextInterval(consecutiveSuccesses: number): number {
+  // Find the highest threshold that we've passed
+  for (let i = HEALTH_CHECK_CONFIG.INTERVALS.length - 1; i >= 0; i--) {
+    const { successCount, interval } = HEALTH_CHECK_CONFIG.INTERVALS[i]
+    if (consecutiveSuccesses >= successCount) {
+      return interval
+    }
+  }
+  return HEALTH_CHECK_CONFIG.INITIAL_INTERVAL
+}
+
+/**
+ * Hook to monitor connection status to the Codebuff backend.
+ * Uses adaptive exponential backoff to reduce polling frequency when connection is stable.
+ */
 export const useConnectionStatus = () => {
+
   const [isConnected, setIsConnected] = useState(true)
 
   useEffect(() => {
     let isMounted = true
+    let timeoutId: NodeJS.Timeout | null = null
+    let consecutiveSuccesses = 0
+    let currentInterval: number = HEALTH_CHECK_CONFIG.INITIAL_INTERVAL
+
+    const scheduleNextCheck = (interval: number) => {
+      if (!isMounted) return
+      timeoutId = setTimeout(() => checkConnection(), interval)
+    }
 
     const checkConnection = async () => {
       const client = getCodebuffClient()
       if (!client) {
         if (isMounted) {
           setIsConnected(false)
+          consecutiveSuccesses = 0
+          currentInterval = HEALTH_CHECK_CONFIG.INITIAL_INTERVAL
+          logger.debug(
+            { interval: currentInterval },
+            'Health check: No client, reset to initial interval',
+          )
+          scheduleNextCheck(currentInterval)
         }
         return
       }
 
       try {
         const connected = await client.checkConnection()
-        if (isMounted) {
-          setIsConnected(connected)
+        if (!isMounted) return
+
+        setIsConnected(connected)
+
+        if (connected) {
+          consecutiveSuccesses++
+          const newInterval = getNextInterval(consecutiveSuccesses)
+
+          // Log when interval changes
+          if (newInterval !== currentInterval) {
+            logger.debug(
+              {
+                consecutiveSuccesses,
+                oldInterval: currentInterval,
+                newInterval,
+              },
+              'Health check interval increased',
+            )
+            currentInterval = newInterval
+          }
+
+          scheduleNextCheck(currentInterval)
+        } else {
+          // Reset to fast polling on connection failure
+          consecutiveSuccesses = 0
+          currentInterval = HEALTH_CHECK_CONFIG.INITIAL_INTERVAL
+          logger.debug(
+            { interval: currentInterval },
+            'Health check failed, reset to initial interval',
+          )
+          scheduleNextCheck(currentInterval)
         }
       } catch (error) {
         logger.debug({ error }, 'Connection check failed')
         if (isMounted) {
           setIsConnected(false)
+          consecutiveSuccesses = 0
+          currentInterval = HEALTH_CHECK_CONFIG.INITIAL_INTERVAL
+          scheduleNextCheck(currentInterval)
         }
       }
     }
 
+    // Start first check immediately
     checkConnection()
-    const interval = setInterval(checkConnection, 30000)
 
     return () => {
       isMounted = false
-      clearInterval(interval)
+      if (timeoutId) {
+        clearTimeout(timeoutId)
+      }
     }
   }, [])