Feature: Live Map and Events Tab

app/api/live/telemetry/route.ts

@@ -0,0 +1,142 @@
+// app/api/live/telemetry/route.ts
+// Server-Sent Events endpoint streaming from C++ Unix socket
+
+import { getTelemetryBridge } from '@/lib/telemetryBridge';
+import { query } from '@/lib/db';
+
+export const dynamic = 'force-dynamic';
+export const runtime = 'nodejs';
+
+// Cache for driver ranks (refreshed periodically)
+let rankCache: Map<string, { rank: number, rating: number }> = new Map();
+let lastRankUpdate = 0;
+const RANK_CACHE_TTL = 60000; // 1 minute
+
+async function updateRankCache() {
+  const now = Date.now();
+  if (now - lastRankUpdate < RANK_CACHE_TTL) {
+    return; // Cache still valid
+  }
+
+  try {
+    // Get all users sorted by rank (higher is better)
+    const users = await query(
+      `SELECT 
+        driver_guid, 
+        user_rank,
+        ROW_NUMBER() OVER (ORDER BY user_rank DESC) as rank_position
+      FROM users 
+      WHERE user_rank IS NOT NULL
+      ORDER BY user_rank DESC`
+    );
+    
+    rankCache.clear();
+    users.forEach((row: any) => {
+      rankCache.set(row.driver_guid.toString(), {
+        rank: row.rank_position,
+        rating: row.user_rank
+      });
+    });
+    
+    lastRankUpdate = now;
+    console.log('[Rank Cache] Updated with', rankCache.size, 'drivers');
+  } catch (error) {
+    console.error('[Rank Cache] Failed to update:', error);
+  }
+}
+
+export async function GET(request: Request) {
+  const { searchParams } = new URL(request.url);
+  const serverId = searchParams.get('serverId');
+  const filterServerId = serverId ? parseInt(serverId) : null;
+
+  const encoder = new TextEncoder();
+  const bridge = getTelemetryBridge();
+  
+  const stream = new ReadableStream({
+    async start(controller) {
+      console.log('[SSE] Client connected', filterServerId ? `(server ${filterServerId})` : '(all servers)');
+      
+      // Update rank cache on new connection
+      await updateRankCache();
+      
+      // Send initial connection message
+      controller.enqueue(encoder.encode(`data: ${JSON.stringify({ 
+        type: 'connected',
+        bridge_status: bridge.isConnected() ? 'connected' : 'connecting',
+        timestamp: Date.now()
+      })}\n\n`));
+
+      // Subscribe to telemetry updates
+      const unsubscribe = bridge.subscribe((packet) => {
+        // Filter by server if specified
+        if (filterServerId && packet.server_id !== filterServerId) {
+          return;
+        }
+
+        // Transform to client format
+        const telemetry = {
+          type: 'update',
+          timestamp: Date.now(),
+          server_id: packet.server_id,
+          cars: packet.cars.map((car) => {
+            const driverRank = rankCache.get(car.driver_guid);
+            return {
+              carID: car.carID,
+              driver_guid: car.driver_guid,
+              driver_name: car.driver_name,
+              car_model: car.car_model,
+              position: car.position_rank,
+              current_lap: car.current_lap,
+              normalizedSplinePos: car.normalizedSplinePos,
+              speed: Math.round(car.speed_kmh),
+              gear: car.gear,
+              rpm: car.rpm,
+              last_lap_time: car.last_lap_time || null,
+              best_lap_time: car.best_lap_time || null,
+              world_position: car.position,
+              user_rank: driverRank ? driverRank.rank : null,
+              user_rating: driverRank ? driverRank.rating : null,
+            };
+          }),
+        };
+
+        try {
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify(telemetry)}\n\n`));
+        } catch (error) {
+          console.error('[SSE] Error sending data:', error);
+        }
+      });
+
+      // Heartbeat every 30 seconds to keep connection alive
+      const heartbeat = setInterval(() => {
+        try {
+          controller.enqueue(encoder.encode(`: heartbeat\n\n`));
+        } catch (error) {
+          clearInterval(heartbeat);
+        }
+      }, 30000);
+
+      // Cleanup on connection close
+      request.signal.addEventListener('abort', () => {
+        console.log('[SSE] Client disconnected');
+        unsubscribe();
+        clearInterval(heartbeat);
+        try {
+          controller.close();
+        } catch (error) {
+          // Controller already closed
+        }
+      });
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache, no-transform',
+      'Connection': 'keep-alive',
+      'X-Accel-Buffering': 'no', // Disable nginx buffering
+    },
+  });
+}