Update index.js

index.js

@@ -250,62 +250,124 @@ app.get('/api/recently-played/json', async (req, res) => {
 });
 
 // 4. Current Playback State endpoint
+async function refreshAccessToken(refreshToken) {
+  const response = await axios.post('https://accounts.spotify.com/api/token', 
+    querystring.stringify({
+      grant_type: 'refresh_token',
+      refresh_token: refreshToken,
+    }), {
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'Authorization': 'Basic ' + Buffer.from(`${CLIENT_ID}:${CLIENT_SECRET}`).toString('base64'),
+      },
+    });
+  return response.data;
+}
+
 app.get('/api/current-playback', async (req, res) => {
-  const accessToken = req.cookies.spotify_access;
-  const userData = req.cookies.spotify_user ? JSON.parse(req.cookies.spotify_user) : null;
+  try {
+    const userId = req.query.user;
+    
+    if (!userId || !userSessions[userId]) {
+      return res.status(401).json({ 
+        error: 'Not authenticated',
+        solution: 'Please login at /login first'
+      });
+    }
 
-  if (!accessToken || !userData) {
-    return res.status(401).json({ error: 'Not authenticated' });
-  }
+    const session = userSessions[userId];
+    
+    // Refresh token if needed
+    if (Date.now() >= session.expiresAt) {
+      try {
+        const newTokens = await refreshAccessToken(session.refreshToken);
+        session.accessToken = newTokens.access_token;
+        session.expiresAt = Date.now() + newTokens.expires_in * 1000;
+      } catch (error) {
+        delete userSessions[userId];
+        return res.status(401).json({ error: 'Session expired' });
+      }
+    }
 
-  try {
+    // Prepare request parameters
     const params = {};
-    if (userData.country) {
-      params.market = userData.country;
+    if (session.country) {
+      params.market = session.country;
     }
 
+    // Get current playback state
     const response = await axios.get('https://api.spotify.com/v1/me/player', {
       params,
-      headers: { 'Authorization': `Bearer ${accessToken}` },
+      headers: { 
+        'Authorization': `Bearer ${session.accessToken}`,
+        'Content-Type': 'application/json'
+      },
     });
 
+    // Handle no content response
     if (response.status === 204) {
-      return res.json({ status: 'success', data: null, message: 'No active playback' });
+      return res.json({ 
+        status: 'success',
+        data: null,
+        message: 'No active playback detected'
+      });
     }
 
+    // Format playback data
     const playbackData = {
-      device: response.data.device,
-      item: {
+      device: {
+        id: response.data.device.id,
+        name: response.data.device.name,
+        type: response.data.device.type,
+        is_active: response.data.device.is_active,
+        volume_percent: response.data.device.volume_percent
+      },
+      track: {
         id: response.data.item.id,
         name: response.data.item.name,
-        artists: response.data.item.artists.map(a => ({ id: a.id, name: a.name })),
+        duration_ms: response.data.item.duration_ms,
+        progress_ms: response.data.progress_ms,
+        is_playing: response.data.is_playing,
+        artists: response.data.item.artists.map(artist => ({
+          id: artist.id,
+          name: artist.name
+        })),
         album: {
           id: response.data.item.album.id,
           name: response.data.item.album.name,
-          images: response.data.item.album.images
-        },
-        duration_ms: response.data.item.duration_ms,
-        progress_ms: response.data.progress_ms
+          images: response.data.item.album.images,
+          release_date: response.data.item.album.release_date
+        }
       },
-      is_playing: response.data.is_playing,
+      context: response.data.context ? {
+        type: response.data.context.type,
+        href: response.data.context.href,
+        uri: response.data.context.uri
+      } : null,
       shuffle_state: response.data.shuffle_state,
-      repeat_state: response.data.repeat_state
+      repeat_state: response.data.repeat_state,
+      timestamp: response.data.timestamp
     };
 
     res.json({
       status: 'success',
       user: {
-        id: userData.id,
-        display_name: userData.display_name
+        id: userId,
+        display_name: session.display_name,
+        country: session.country
       },
       data: playbackData
     });
+
   } catch (error) {
+    console.error('Playback error:', error.response?.data || error.message);
+    
     if (error.response?.status === 401) {
-      return res.status(401).json({ error: 'Session expired' });
+      return res.status(401).json({ error: 'Invalid or expired token' });
     }
+    
     res.status(500).json({ 
-      error: 'Failed to fetch playback state',
+      error: 'Failed to get playback state',
       details: error.response?.data || error.message
     });
   }