fix image cdn, added better error handling

Author: ndbroadbent

CLAUDE.md

@@ -359,7 +359,8 @@ The CLI config file is at `~/.config/chat-to-map/config.json`:
 ## Media Library
 
 **Local path:** `/Users/ndbroadbent/code/chat_to_map_worktrees/media-library/media_library/images/`
-**CDN:** `https://media.chattomap.com/images/` (synced via rclone to R2)
+**CDN:** `https://media.chattomap.com/images/` for image assets, with the index at
+`https://media.chattomap.com/index.json.gz` (synced via rclone to R2)
 
 ```
 images/

src/images/index.test.ts

@@ -2,7 +2,7 @@
  * Images Module Tests
  */
 
-import { beforeEach, describe, expect, it } from 'vitest'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
 import type { CachedResponse, ResponseCache } from '../caching/types'
 import { createGeocodedActivity } from '../test-support'
 import type { GeocodedActivity } from '../types/place-lookup'
@@ -33,6 +33,7 @@ function createMockActivity(overrides: Partial<GeocodedActivity> = {}): Geocoded
 
 describe('Images Module', () => {
   beforeEach(() => {
+    vi.restoreAllMocks()
     clearMediaIndexCache()
   })
 
@@ -251,5 +252,33 @@ describe('Images Module', () => {
 
       expect(results.size).toBe(0)
     })
+
+    it('caches a missing media index so preview image fetches do not refetch it per activity', async () => {
+      const cache = createMockCache()
+      const activities = [
+        createMockActivity({ activity: 'Coffee' }),
+        createMockActivity({ activity: 'Dinner' }),
+        createMockActivity({ activity: 'Walk' })
+      ]
+      const config: ImageFetchConfig = {
+        skipGooglePlaces: true,
+        skipPexels: true,
+        skipPixabay: true
+      }
+      const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue({
+        ok: false,
+        status: 404
+      } as Response)
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => undefined)
+
+      const results = await fetchImagesForActivities(activities, config, cache)
+
+      expect(results.size).toBe(3)
+      expect(results.get(activities[0]?.activityId ?? '')).toBeNull()
+      expect(results.get(activities[1]?.activityId ?? '')).toBeNull()
+      expect(results.get(activities[2]?.activityId ?? '')).toBeNull()
+      expect(fetchSpy).toHaveBeenCalledTimes(1)
+      expect(warnSpy).not.toHaveBeenCalled()
+    })
   })
 })

src/images/index.ts

@@ -69,9 +69,10 @@ export {
   type LicenseCheckResult
 } from './wikipedia-license'
 
-/** Cached media index - loaded once per session */
-let cachedMediaIndex: MediaIndex | null = null
+/** Cached media index - `undefined` means not loaded yet, `null` means unavailable. */
+let cachedMediaIndex: MediaIndex | null | undefined
 let mediaIndexPath: string | null = null
+let mediaIndexPromise: Promise<MediaIndex | null> | null = null
 
 /**
  * Fetch an image for a single activity.
@@ -335,26 +336,39 @@ async function tryMediaLibraryCategoryFallback(
 async function getMediaIndex(config: ImageFetchConfig): Promise<MediaIndex | null> {
   const currentPath = config.mediaLibraryPath ?? null
 
-  // Return cached index if path matches
-  if (cachedMediaIndex !== null && mediaIndexPath === currentPath) {
+  if (mediaIndexPath !== currentPath) {
+    cachedMediaIndex = undefined
+    mediaIndexPath = currentPath
+    mediaIndexPromise = null
+  }
+
+  if (cachedMediaIndex !== undefined) {
     return cachedMediaIndex
   }
 
-  // Load and cache
-  cachedMediaIndex = await loadMediaIndex({
-    localPath: config.mediaLibraryPath
-  })
-  mediaIndexPath = currentPath
+  if (!mediaIndexPromise) {
+    mediaIndexPromise = loadMediaIndex({
+      localPath: config.mediaLibraryPath
+    }).then((index) => {
+      cachedMediaIndex = index
+      return index
+    })
+  }
 
-  return cachedMediaIndex
+  try {
+    return await mediaIndexPromise
+  } finally {
+    mediaIndexPromise = null
+  }
 }
 
 /**
  * Clear cached media index (useful for testing).
  */
 export function clearMediaIndexCache(): void {
-  cachedMediaIndex = null
+  cachedMediaIndex = undefined
   mediaIndexPath = null
+  mediaIndexPromise = null
 }
 
 /**

src/images/media-index.test.ts

@@ -1,11 +1,13 @@
-import { describe, expect, it } from 'vitest'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
 import {
   buildImageUrl,
   findActionFallbackImage,
   findCategoryFallbackImage,
   findCountryImage,
   findObjectImage,
+  loadMediaIndex,
   MEDIA_CDN_URL,
+  MEDIA_INDEX_URL,
   type MediaIndex,
   resolveEntry
 } from './media-index'
@@ -56,6 +58,26 @@ const TEST_INDEX: MediaIndex = {
   }
 }
 
+beforeEach(() => {
+  vi.restoreAllMocks()
+})
+
+describe('loadMediaIndex', () => {
+  it('returns null without warning when the CDN index is missing', async () => {
+    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue({
+      ok: false,
+      status: 404
+    } as Response)
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => undefined)
+
+    await expect(loadMediaIndex()).resolves.toBeNull()
+
+    expect(fetchSpy).toHaveBeenCalledWith(MEDIA_INDEX_URL, undefined)
+    expect(fetchSpy).toHaveBeenCalledTimes(1)
+    expect(warnSpy).not.toHaveBeenCalled()
+  })
+})
+
 describe('resolveEntry', () => {
   it('resolves direct hash', () => {
     const result = resolveEntry('abc123', 'objects', 'swimming')

src/images/media-index.ts

@@ -15,6 +15,8 @@ import { httpFetch } from '../http'
 
 /** CDN base URL for media library */
 export const MEDIA_CDN_URL = 'https://media.chattomap.com/images'
+/** CDN URL for the gzipped media index */
+export const MEDIA_INDEX_URL = 'https://media.chattomap.com/index.json.gz'
 
 /** Available image sizes in the media library */
 export const IMAGE_SIZES = [1400, 700, 400, 128] as const
@@ -115,16 +117,30 @@ export async function loadMediaIndex(options?: MediaIndexOptions): Promise<Media
     }
     return await loadCdnIndex()
   } catch (error) {
+    if (isMissingMediaIndexError(error)) {
+      return null
+    }
     console.warn('Failed to load media index:', error)
     return null
   }
 }
 
+function isMissingMediaIndexError(error: unknown): boolean {
+  if (!(error instanceof Error)) {
+    return false
+  }
+
+  return (
+    error.message === 'Failed to fetch media index: 404' ||
+    error.message.startsWith('Media index not found at ')
+  )
+}
+
 /**
  * Load index from CDN (gzipped).
  */
 async function loadCdnIndex(): Promise<MediaIndex> {
-  const response = await httpFetch(`${MEDIA_CDN_URL}/index.json.gz`)
+  const response = await httpFetch(MEDIA_INDEX_URL)
   if (!response.ok) {
     throw new Error(`Failed to fetch media index: ${response.status}`)
   }

src/place-lookup/coordinates.ts

@@ -0,0 +1,39 @@
+import type { GeocodedActivity } from '../types'
+
+/**
+ * Count activities with coordinates.
+ */
+export function countWithCoordinates(activities: readonly GeocodedActivity[]): number {
+  return activities.filter((a) => a.latitude !== undefined && a.longitude !== undefined).length
+}
+
+/**
+ * Filter to only activities with coordinates.
+ */
+export function filterWithCoordinates(activities: readonly GeocodedActivity[]): GeocodedActivity[] {
+  return activities.filter(
+    (a): a is GeocodedActivity & { latitude: number; longitude: number } =>
+      a.latitude !== undefined && a.longitude !== undefined
+  )
+}
+
+/**
+ * Calculate the center point of activities with coordinates.
+ */
+export function calculateCenter(
+  activities: readonly GeocodedActivity[]
+): { lat: number; lng: number } | null {
+  const withCoords = filterWithCoordinates(activities)
+
+  if (withCoords.length === 0) {
+    return null
+  }
+
+  const sumLat = withCoords.reduce((sum, a) => sum + (a.latitude as number), 0)
+  const sumLng = withCoords.reduce((sum, a) => sum + (a.longitude as number), 0)
+
+  return {
+    lat: sumLat / withCoords.length,
+    lng: sumLng / withCoords.length
+  }
+}

src/place-lookup/index.test.ts

@@ -317,6 +317,46 @@ describe('Geocoder Module', () => {
 
       expect(results.activities[0]?.latitude).toBeCloseTo(48.8, 1)
       expect(results.activities[0]?.placeLookupSource).toBe('places_api')
+      expect(results.activities[0]?.matchedPlaceName).toBe('Eiffel Tower')
+    })
+
+    it('preserves the matched Google place name for venue lookups', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: async () =>
+          createPlacesResponse(
+            -36.8734,
+            174.7606,
+            '193 Symonds Street, Eden Terrace, Auckland 1010, New Zealand',
+            'Kazuya'
+          )
+      })
+
+      const activity = createTestActivity({
+        activity: 'Dinner at Kazuya',
+        category: 'food',
+        score: 0.9,
+        placeQuery: 'Kazuya',
+        city: 'Auckland',
+        messages: [
+          {
+            id: 1,
+            sender: 'Test User',
+            timestamp: new Date('2025-01-15T10:30:00Z'),
+            message: 'Dinner at Kazuya'
+          }
+        ]
+      })
+
+      const results = await lookupActivityPlaces([activity], {
+        apiKey: 'test-key'
+      })
+
+      expect(results.activities[0]?.placeLookupSource).toBe('places_api')
+      expect(results.activities[0]?.matchedPlaceName).toBe('Kazuya')
+      expect(results.activities[0]?.formattedAddress).toBe(
+        '193 Symonds Street, Eden Terrace, Auckland 1010, New Zealand'
+      )
     })
 
     it('returns activity without coordinates when all geocoding fails', async () => {
@@ -337,6 +377,33 @@ describe('Geocoder Module', () => {
       expect(results.activities[0]?.longitude).toBeUndefined()
     })
 
+    it('logs provider errors when Google denies the lookup', async () => {
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => undefined)
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: async () => ({
+          status: 'REQUEST_DENIED',
+          results: [],
+          error_message: 'Billing disabled'
+        })
+      })
+
+      const activity = createActivity(1, 'Rotoroa Island', 'Auckland')
+
+      const results = await lookupActivityPlaces([activity], {
+        apiKey: 'test-key'
+      })
+
+      expect(results.activities[0]?.latitude).toBeUndefined()
+      expect(warnSpy).toHaveBeenCalledWith(
+        '[place-lookup] geocoding failed for "Auckland": Billing disabled'
+      )
+      expect(warnSpy).toHaveBeenCalledWith(
+        '[place-lookup] activity fallback search failed for "Rotoroa Island": Billing disabled'
+      )
+    })
+
     it('handles activities without location', async () => {
       const activity = createActivity(1, 'Some activity')