Sync public snapshot from freebuff-private

Source: CodebuffAI/freebuff-private@5e2cfb5098ad8551c77db0ba3e690acaea240079

Author: github-actions[bot]

cli/src/utils/__tests__/osc-timeout-scenarios.test.ts

@@ -1,7 +1,7 @@
 import { describe, test, expect } from 'bun:test'
+import { withTimeoutOr } from '@codebuff/common/util/promise'
 
 import {
-  withTimeout,
   getGlobalOscTimeout,
   getQueryOscTimeout,
 } from '../terminal-color-detection'
@@ -13,14 +13,14 @@ import {
 
 describe('OSC Timeout Protection Scenarios', () => {
   describe('Scenario 1: Terminal ignores OSC queries entirely', () => {
-    test('withTimeout returns fallback value when promise never resolves', async () => {
+    test('withTimeoutOr returns fallback value when promise never resolves', async () => {
       // Simulate a terminal that ignores the OSC query completely
       const neverResolvingPromise = new Promise<string>(() => {
         // This promise never resolves, simulating a non-responsive terminal
       })
 
       const startTime = Date.now()
-      const result = await withTimeout(neverResolvingPromise, 100, 'fallback')
+      const result = await withTimeoutOr(neverResolvingPromise, 100, 'fallback')
       const elapsed = Date.now() - startTime
 
       expect(result).toBe('fallback')
@@ -31,27 +31,27 @@ describe('OSC Timeout Protection Scenarios', () => {
     test('returns null theme when detection hangs', async () => {
       const hangingDetection = new Promise<'dark' | 'light' | null>(() => {})
 
-      const result = await withTimeout(hangingDetection, 50, null)
+      const result = await withTimeoutOr(hangingDetection, 50, null)
       expect(result).toBeNull()
     })
   })
 
   describe('Scenario 2: Terminal responds very slowly', () => {
-    test('withTimeout returns fallback for slow responses', async () => {
+    test('withTimeoutOr returns fallback for slow responses', async () => {
       const slowPromise = new Promise<string>((resolve) => {
         setTimeout(() => resolve('slow-response'), 500)
       })
 
-      const result = await withTimeout(slowPromise, 100, 'timeout-fallback')
+      const result = await withTimeoutOr(slowPromise, 100, 'timeout-fallback')
       expect(result).toBe('timeout-fallback')
     })
 
-    test('withTimeout returns actual value for responses within timeout', async () => {
+    test('withTimeoutOr returns actual value for responses within timeout', async () => {
       const fastPromise = new Promise<string>((resolve) => {
         setTimeout(() => resolve('fast-response'), 10)
       })
 
-      const result = await withTimeout(fastPromise, 100, 'timeout-fallback')
+      const result = await withTimeoutOr(fastPromise, 100, 'timeout-fallback')
       expect(result).toBe('fast-response')
     })
   })
@@ -71,7 +71,7 @@ describe('OSC Timeout Protection Scenarios', () => {
     test('multiple timeouts racing dont cause issues', async () => {
       // Create multiple promises that might complete at similar times
       const promises = Array.from({ length: 10 }, (_, i) =>
-        withTimeout(
+        withTimeoutOr(
           new Promise<number>((resolve) =>
             setTimeout(() => resolve(i), Math.random() * 100),
           ),
@@ -89,17 +89,17 @@ describe('OSC Timeout Protection Scenarios', () => {
     })
 
     test('cleanup happens even on timeout', async () => {
-      // This test verifies that withTimeout properly cleans up its own timeout
+      // This test verifies that withTimeoutOr properly cleans up its own timeout
       // even when the underlying promise doesn't resolve
       const neverResolves = new Promise<string>(() => {
         // This promise intentionally never resolves
       })
 
       // This should timeout and return the fallback value
-      const result = await withTimeout(neverResolves, 50, 'timeout')
+      const result = await withTimeoutOr(neverResolves, 50, 'timeout')
       expect(result).toBe('timeout')
 
-      // Note: withTimeout cleans up its own setTimeout via the finally block
+      // Note: withTimeoutOr cleans up its own setTimeout via the finally block
       // The underlying promise's resources would need to be cleaned up separately
     })
   })
@@ -125,34 +125,34 @@ describe('OSC Timeout Protection Scenarios', () => {
   })
 
   describe('Scenario 6: Error handling', () => {
-    test('rejected promises propagate through withTimeout', async () => {
+    test('rejected promises propagate through withTimeoutOr', async () => {
       const rejectingPromise = Promise.reject(new Error('test error'))
 
       await expect(
-        withTimeout(rejectingPromise, 100, 'fallback'),
+        withTimeoutOr(rejectingPromise, 100, 'fallback'),
       ).rejects.toThrow('test error')
     })
 
     test('timeout value can be any type', async () => {
       const hangingPromise = new Promise<{ theme: string }>(() => {})
 
-      const objectResult = await withTimeout(hangingPromise, 50, {
+      const objectResult = await withTimeoutOr(hangingPromise, 50, {
         theme: 'default',
       })
       expect(objectResult).toEqual({ theme: 'default' })
 
       const hangingPromise2 = new Promise<number[]>(() => {})
-      const arrayResult = await withTimeout(hangingPromise2, 50, [1, 2, 3])
+      const arrayResult = await withTimeoutOr(hangingPromise2, 50, [1, 2, 3])
       expect(arrayResult).toEqual([1, 2, 3])
     })
   })
 
   describe('Scenario 7: Stacked timeouts (defense in depth)', () => {
     test('inner timeout fires before outer timeout', async () => {
       const innerPromise = new Promise<string>(() => {})
-      const innerResult = withTimeout(innerPromise, 30, 'inner-timeout')
+      const innerResult = withTimeoutOr(innerPromise, 30, 'inner-timeout')
 
-      const outerPromise = withTimeout(innerResult, 100, 'outer-timeout')
+      const outerPromise = withTimeoutOr(innerResult, 100, 'outer-timeout')
 
       const result = await outerPromise
       // Inner timeout should fire first
@@ -165,7 +165,7 @@ describe('OSC Timeout Protection Scenarios', () => {
         // This never resolves, simulating broken inner timeout
       })
 
-      const result = await withTimeout(brokenInnerPromise, 50, 'outer-saved-us')
+      const result = await withTimeoutOr(brokenInnerPromise, 50, 'outer-saved-us')
       expect(result).toBe('outer-saved-us')
     })
   })

cli/src/utils/__tests__/terminal-color-detection.test.ts

@@ -1,12 +1,12 @@
 import { describe, test, expect, beforeEach, afterEach } from 'bun:test'
+import { withTimeoutOr } from '@codebuff/common/util/promise'
 
 import {
   parseOSCResponse,
   calculateBrightness,
   themeFromBgColor,
   themeFromFgColor,
   terminalSupportsOSC,
-  withTimeout,
   getGlobalOscTimeout,
   getQueryOscTimeout,
 } from '../terminal-color-detection'
@@ -196,48 +196,48 @@ describe('themeFromFgColor', () => {
 })
 
 // ============================================================================
-// withTimeout Tests
+// withTimeoutOr Tests
 // ============================================================================
 
-describe('withTimeout', () => {
+describe('withTimeoutOr', () => {
   test('returns promise result if it resolves before timeout', async () => {
     const fastPromise = Promise.resolve('success')
-    const result = await withTimeout(fastPromise, 1000, 'timeout')
+    const result = await withTimeoutOr(fastPromise, 1000, 'timeout')
     expect(result).toBe('success')
   })
 
   test('returns timeout value if promise takes too long', async () => {
     const slowPromise = new Promise<string>((resolve) => {
       setTimeout(() => resolve('late'), 500)
     })
-    const result = await withTimeout(slowPromise, 50, 'timeout')
+    const result = await withTimeoutOr(slowPromise, 50, 'timeout')
     expect(result).toBe('timeout')
   })
 
   test('returns null timeout value', async () => {
     const slowPromise = new Promise<string | null>((resolve) => {
       setTimeout(() => resolve('late'), 500)
     })
-    const result = await withTimeout(slowPromise, 50, null)
+    const result = await withTimeoutOr(slowPromise, 50, null)
     expect(result).toBeNull()
   })
 
   test('clears timeout after promise resolves', async () => {
     const fastPromise = Promise.resolve('success')
     // This should not cause any issues with dangling timeouts
-    await withTimeout(fastPromise, 10000, 'timeout')
+    await withTimeoutOr(fastPromise, 10000, 'timeout')
     // If the timeout wasn't cleared, this test would hang
   })
 
   test('handles rejected promises', async () => {
     const failingPromise = Promise.reject(new Error('test error'))
-    await expect(withTimeout(failingPromise, 1000, 'timeout')).rejects.toThrow(
+    await expect(withTimeoutOr(failingPromise, 1000, 'timeout')).rejects.toThrow(
       'test error',
     )
   })
 
   test('handles immediate resolution', async () => {
-    const result = await withTimeout(Promise.resolve(42), 0, -1)
+    const result = await withTimeoutOr(Promise.resolve(42), 0, -1)
     // Promise.resolve is always faster than setTimeout(0)
     expect(result).toBe(42)
   })

cli/src/utils/auth-token-store.ts

@@ -22,6 +22,7 @@
  */
 
 import { getCliEnv } from './env'
+import { withTimeout } from '@codebuff/common/util/promise'
 
 export type SecretStore = {
   get(): Promise<string | null>
@@ -31,21 +32,7 @@ export type SecretStore = {
 
 const KEYCHAIN_TIMEOUT_MS = 2_000
 
-function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T> {
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => reject(new Error('keychain timed out')), ms)
-    promise.then(
-      (value) => {
-        clearTimeout(timer)
-        resolve(value)
-      },
-      (error) => {
-        clearTimeout(timer)
-        reject(error)
-      },
-    )
-  })
-}
+const KEYCHAIN_TIMEOUT_MESSAGE = 'keychain timed out'
 
 type BunSecrets = {
   get(options: { service: string; name: string }): Promise<string | null>
@@ -63,11 +50,24 @@ export function bunSecretStore(
     ?.secrets
   if (!secrets) return null
   return {
-    get: () => withTimeout(secrets.get({ service, name }), KEYCHAIN_TIMEOUT_MS),
+    get: () =>
+      withTimeout(
+        secrets.get({ service, name }),
+        KEYCHAIN_TIMEOUT_MS,
+        KEYCHAIN_TIMEOUT_MESSAGE,
+      ),
     set: (value) =>
-      withTimeout(secrets.set({ service, name, value }), KEYCHAIN_TIMEOUT_MS),
+      withTimeout(
+        secrets.set({ service, name, value }),
+        KEYCHAIN_TIMEOUT_MS,
+        KEYCHAIN_TIMEOUT_MESSAGE,
+      ),
     delete: async () => {
-      await withTimeout(secrets.delete({ service, name }), KEYCHAIN_TIMEOUT_MS)
+      await withTimeout(
+        secrets.delete({ service, name }),
+        KEYCHAIN_TIMEOUT_MS,
+        KEYCHAIN_TIMEOUT_MESSAGE,
+      )
     },
   }
 }

cli/src/utils/exit-cleanly.ts

@@ -1,11 +1,11 @@
+import { withTimeoutOr } from '@codebuff/common/util/promise'
 import { flushAdEngagementOnExit } from '../ads/use-ad-engagement'
 import { flushAnalytics } from './analytics'
 import { IS_FREEBUFF } from './constants'
 import { stopEngagementTracking } from './engagement'
 import { useFreebuffSessionStore } from '../state/freebuff-session-store'
 import { drainClientLogs } from './log-shipper'
 import { settleInterruptedSponsoredRun } from './sponsored-run-exit'
-import { withTimeout } from './terminal-color-detection'
 
 const EXIT_CLEANUP_TIMEOUT_MS = 1_000
 
@@ -134,7 +134,7 @@ export const exitCliCleanly = createExitCliCleanly({
     }
   },
   waitForRemoteCleanup: async (tasks) => {
-    await withTimeout(
+    await withTimeoutOr(
       Promise.allSettled(tasks),
       EXIT_CLEANUP_TIMEOUT_MS,
       undefined,

cli/src/utils/terminal-color-detection.ts

@@ -12,39 +12,14 @@
 import { openSync, closeSync, writeSync, constants } from 'fs'
 
 import { getCliEnv } from './env'
+import { withTimeoutOr } from '@codebuff/common/util/promise'
 
 import type { CliEnv } from '../types/env'
 
 // Timeout constants
 const OSC_QUERY_TIMEOUT_MS = 500 // Timeout for individual OSC query
 const GLOBAL_OSC_TIMEOUT_MS = 2000 // Global timeout for entire detection process
 
-/**
- * Wrap a promise with a timeout
- * @param promise - The promise to wrap
- * @param timeoutMs - Timeout in milliseconds
- * @param timeoutValue - Value to return on timeout
- */
-export function withTimeout<T>(
-  promise: Promise<T>,
-  timeoutMs: number,
-  timeoutValue: T,
-): Promise<T> {
-  let timeoutId: NodeJS.Timeout | null = null
-
-  const timeoutPromise = new Promise<T>((resolve) => {
-    timeoutId = setTimeout(() => {
-      resolve(timeoutValue)
-    }, timeoutMs)
-  })
-
-  return Promise.race([promise, timeoutPromise]).finally(() => {
-    if (timeoutId) {
-      clearTimeout(timeoutId)
-    }
-  })
-}
-
 /**
  * Check if the current terminal supports OSC color queries
  */
@@ -449,7 +424,7 @@ async function detectTerminalThemeCore(
  */
 export async function detectTerminalTheme(): Promise<'dark' | 'light' | null> {
   try {
-    return await withTimeout(
+    return await withTimeoutOr(
       detectTerminalThemeCore(),
       GLOBAL_OSC_TIMEOUT_MS,
       null,