ethagent 1.1.2 → 2.0.0

package/src/ui/theme.ts

@@ -1,29 +1,16 @@
 export const palette: Array<[number, number, number]> = [
   [0xff, 0xff, 0xff],
-  [0xf2, 0xf9, 0xf4],
-  [0xe7, 0xf4, 0xec],
-  [0xd4, 0xee, 0xdd],
-  [0xe7, 0xf4, 0xec],
+  [0xd8, 0xdc, 0xfa],
+  [0xe8, 0xee, 0xfd],
+  [0xd8, 0xdc, 0xfa],
   [0xff, 0xff, 0xff],
 ]
 
-export const eyePalette: Array<[number, number, number]> = [
-  [0xf5, 0xd8, 0xd8],
-  [0xf5, 0xe7, 0xcf],
-  [0xf5, 0xf0, 0xd4],
-  [0xd4, 0xee, 0xdd],
-  [0xd4, 0xe6, 0xf5],
-] as const
-
 export const theme = {
-  accentPrimary: '#d4eedd',
-  accentWarm: '#d8cda8',
-  accentNeutral: '#e4e3b5',
-  accentSecondary: '#c0e3cb',
-  accentMint: '#e7f4ec',
-  accentPeach: '#e7cdb7',
-  accentLavender: '#d9cae8',
-  accentInfo: '#90b8e8',
+  accentPeriwinkle: '#d8dcfa',
+  accentBlue: '#e8eefd',
+  accentWhite: '#f5f8ff',
+  accentError: '#d99898',
   border: '#555555',
   dim: '#777777',
   text: '#f1f1f1',
@@ -43,17 +30,3 @@ export function gradientColor(t: number): string {
   const b = Math.round(b1 + (b2 - b1) * f)
   return `#${r.toString(16).padStart(2, '0')}${g.toString(16).padStart(2, '0')}${b.toString(16).padStart(2, '0')}`
 }
-
-export function eyeGradientColor(t: number): string {
-  const s = Math.max(0, Math.min(1, t)) * (eyePalette.length - 1)
-  const i = Math.min(Math.floor(s), eyePalette.length - 2)
-  const f = s - i
-  const lo = eyePalette[i] ?? eyePalette[0]!
-  const hi = eyePalette[i + 1] ?? eyePalette[eyePalette.length - 1]!
-  const [r1, g1, b1] = lo
-  const [r2, g2, b2] = hi
-  const r = Math.round(r1 + (r2 - r1) * f)
-  const g = Math.round(g1 + (g2 - g1) * f)
-  const b = Math.round(b1 + (b2 - b1) * f)
-  return `#${r.toString(16).padStart(2, '0')}${g.toString(16).padStart(2, '0')}${b.toString(16).padStart(2, '0')}`
-}

package/src/utils/openExternal.ts

@@ -0,0 +1,21 @@
+import { spawn } from 'node:child_process'
+
+export function openExternalUrl(url: string): void {
+  const target = url.trim()
+  if (!target) return
+  const command = process.platform === 'win32'
+    ? 'cmd'
+    : process.platform === 'darwin'
+      ? 'open'
+      : 'xdg-open'
+  const args = process.platform === 'win32'
+    ? ['/c', 'start', '', target]
+    : [target]
+  const child = spawn(command, args, {
+    detached: true,
+    stdio: 'ignore',
+    windowsHide: true,
+  })
+  child.on('error', () => {})
+  child.unref()
+}

package/src/utils/withRetry.ts

@@ -6,6 +6,12 @@ export type RetryClassification = {
   code?: string
 }
 
+export type RetryBodyHint = {
+  retryAfterMs?: number
+  fatal?: boolean
+  reason?: string
+}
+
 export type RetryPolicy = {
   maxRetries: number
   baseDelayMs: number
@@ -179,6 +185,7 @@ export type FetchWithRetryOptions = {
   retryAfterCapMs?: number
   jitterRatio?: number
   rateLimitResetProvider?: RateLimitResetProvider
+  parseRetryHintFromBody?: (body: string) => RetryBodyHint | undefined
   signal?: AbortSignal
   fetchImpl?: typeof fetch
   sleep?: (ms: number, signal?: AbortSignal) => Promise<void>
@@ -205,10 +212,36 @@ export async function fetchWithRetry(
       const response = await fetchImpl(input, { ...init, signal: options.signal })
       if (response.ok) return response
 
-      const classification = classifyRetryableProviderResponse(response, now(), options.rateLimitResetProvider)
-      if (!classification.retryable || attempt > policy.maxRetries) return response
+      let classification = classifyRetryableProviderResponse(response, now(), options.rateLimitResetProvider)
+      let bufferedResponse: Response | undefined
+      if (
+        classification.retryable
+        && response.status === 429
+        && options.parseRetryHintFromBody
+      ) {
+        let bodyText = ''
+        try { bodyText = await response.text() } catch { /* ignore */ }
+        bufferedResponse = new Response(bodyText, {
+          status: response.status,
+          statusText: response.statusText,
+          headers: response.headers,
+        })
+        const hint = bodyText ? safeParseRetryHint(bodyText, options.parseRetryHintFromBody) : undefined
+        if (hint?.fatal) {
+          return bufferedResponse
+        }
+        if (hint?.retryAfterMs !== undefined) {
+          classification = { ...classification, retryAfterMs: hint.retryAfterMs }
+        }
+        if (hint?.reason) {
+          classification = { ...classification, reason: `${classification.reason} ${hint.reason}` }
+        }
+      }
+      if (!classification.retryable || attempt > policy.maxRetries) return bufferedResponse ?? response
 
-      try { await response.body?.cancel() } catch { /* ignore */ }
+      if (!bufferedResponse) {
+        try { await response.body?.cancel() } catch { /* ignore */ }
+      }
       const delayMs = computeBackoffMs(
         attempt,
         classification.retryAfterMs,
@@ -243,6 +276,17 @@ export async function fetchWithRetry(
   throw lastError ?? new Error('fetchWithRetry exhausted')
 }
 
+function safeParseRetryHint(
+  body: string,
+  parser: (body: string) => RetryBodyHint | undefined,
+): RetryBodyHint | undefined {
+  try {
+    return parser(body)
+  } catch {
+    return undefined
+  }
+}
+
 function retryEvent(
   attempt: number,
   maxRetries: number,